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

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

@@ -0,0 +1,119 @@
+import { getDpCodeByDpId, getDpIdByDpCode } from '../ScheduleUtils';
+import { getScheduleCache } from '../ScheduleCache';
+
+// 模拟依赖
+jest.mock('../ScheduleCache', () => ({
+  getScheduleCache: jest.fn()
+}));
+describe('ScheduleUtils', () => {
+  const mockDevInfo = {
+    devId: 'test-device-id',
+    schema: [{
+      id: 1,
+      code: 'switch_led'
+    }, {
+      id: 2,
+      code: 'bright_value'
+    }, {
+      id: 3,
+      code: 'colour_data'
+    }]
+  };
+  const mockGroupInfo = {
+    groupId: 'test-group-id',
+    schema: [{
+      id: 1,
+      code: 'switch_led'
+    }, {
+      id: 2,
+      code: 'bright_value'
+    }]
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('getDpCodeByDpId', () => {
+    it('应该根据DP ID返回对应的DP Code（设备信息）', () => {
+      // 模拟设备信息
+      getScheduleCache.mockImplementation(key => {
+        if (key === 'devInfo') return mockDevInfo;
+        if (key === 'groupInfo') return null;
+        return null;
+      });
+      expect(getDpCodeByDpId(1)).toBe('switch_led');
+      expect(getDpCodeByDpId(2)).toBe('bright_value');
+      expect(getDpCodeByDpId(3)).toBe('colour_data');
+      expect(getDpCodeByDpId(4)).toBeNull(); // 不存在的DP ID
+
+      // 验证调用了getScheduleCache
+      expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
+      expect(getScheduleCache).toHaveBeenCalledWith('groupInfo');
+    });
+    it('应该根据DP ID返回对应的DP Code（群组信息）', () => {
+      // 模拟没有设备信息，只有群组信息
+      getScheduleCache.mockImplementation(key => {
+        if (key === 'devInfo') return null;
+        if (key === 'groupInfo') return mockGroupInfo;
+        return null;
+      });
+      expect(getDpCodeByDpId(1)).toBe('switch_led');
+      expect(getDpCodeByDpId(2)).toBe('bright_value');
+      expect(getDpCodeByDpId(3)).toBeNull(); // 群组中不存在的DP ID
+
+      // 验证调用了getScheduleCache
+      expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
+      expect(getScheduleCache).toHaveBeenCalledWith('groupInfo');
+    });
+    it('当没有设备信息和群组信息时应该返回null', () => {
+      // 模拟没有设备信息和群组信息
+      getScheduleCache.mockReturnValue(null);
+      expect(getDpCodeByDpId(1)).toBeNull();
+
+      // 验证调用了getScheduleCache
+      expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
+      expect(getScheduleCache).toHaveBeenCalledWith('groupInfo');
+    });
+  });
+  describe('getDpIdByDpCode', () => {
+    it('应该根据DP Code返回对应的DP ID（设备信息）', () => {
+      // 模拟设备信息
+      getScheduleCache.mockImplementation(key => {
+        if (key === 'devInfo') return mockDevInfo;
+        if (key === 'groupInfo') return null;
+        return null;
+      });
+      expect(getDpIdByDpCode('switch_led')).toBe(1);
+      expect(getDpIdByDpCode('bright_value')).toBe(2);
+      expect(getDpIdByDpCode('colour_data')).toBe(3);
+      expect(getDpIdByDpCode('non_existent')).toBeNull(); // 不存在的DP Code
+
+      // 验证调用了getScheduleCache
+      expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
+      expect(getScheduleCache).toHaveBeenCalledWith('groupInfo');
+    });
+    it('应该根据DP Code返回对应的DP ID（群组信息）', () => {
+      // 模拟没有设备信息，只有群组信息
+      getScheduleCache.mockImplementation(key => {
+        if (key === 'devInfo') return null;
+        if (key === 'groupInfo') return mockGroupInfo;
+        return null;
+      });
+      expect(getDpIdByDpCode('switch_led')).toBe(1);
+      expect(getDpIdByDpCode('bright_value')).toBe(2);
+      expect(getDpIdByDpCode('colour_data')).toBeNull(); // 群组中不存在的DP Code
+
+      // 验证调用了getScheduleCache
+      expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
+      expect(getScheduleCache).toHaveBeenCalledWith('groupInfo');
+    });
+    it('当没有设备信息和群组信息时应该返回null', () => {
+      // 模拟没有设备信息和群组信息
+      getScheduleCache.mockReturnValue(null);
+      expect(getDpIdByDpCode('switch_led')).toBeNull();
+
+      // 验证调用了getScheduleCache
+      expect(getScheduleCache).toHaveBeenCalledWith('devInfo');
+      expect(getScheduleCache).toHaveBeenCalledWith('groupInfo');
+    });
+  });
+});

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

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

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

@@ -0,0 +1,147 @@
+import { isNum, findMinMissingNum, getSafeAreaPadding, timeStrToMinutes, minutesToTimeStr } from '../common';
+import { getCachedSystemInfo } from '../getCachedSystemInfo';
+
+// 模拟依赖
+jest.mock('../getCachedSystemInfo', () => ({
+  getCachedSystemInfo: jest.fn()
+}));
+describe('common', () => {
+  describe('isNum', () => {
+    it('应该正确判断数字', () => {
+      expect(isNum(0)).toBe(true);
+      expect(isNum(1)).toBe(true);
+      expect(isNum(-1)).toBe(true);
+      expect(isNum(1.5)).toBe(true);
+      expect(isNum(Number.MAX_SAFE_INTEGER)).toBe(true);
+      expect(isNum(Number.MIN_SAFE_INTEGER)).toBe(true);
+    });
+    it('应该正确判断非数字', () => {
+      expect(isNum(null)).toBe(false);
+      expect(isNum(undefined)).toBe(false);
+      expect(isNum('1')).toBe(false);
+      expect(isNum('abc')).toBe(false);
+      expect(isNum({})).toBe(false);
+      expect(isNum([])).toBe(false);
+      expect(isNum(NaN)).toBe(false);
+      expect(isNum(Infinity)).toBe(false);
+      expect(isNum(-Infinity)).toBe(false);
+    });
+  });
+  describe('findMinMissingNum', () => {
+    it('应该找到数组中缺失的最小正整数', () => {
+      expect(findMinMissingNum([1, 2, 3, 4, 5])).toBe(6);
+      expect(findMinMissingNum([2, 3, 4, 5])).toBe(1);
+      expect(findMinMissingNum([1, 3, 4, 5])).toBe(2);
+      expect(findMinMissingNum([1, 2, 4, 5])).toBe(3);
+      expect(findMinMissingNum([1, 2, 3, 5])).toBe(4);
+      expect(findMinMissingNum([6, 7, 8, 9, 10])).toBe(1);
+      expect(findMinMissingNum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])).toBe(null); // 超出范围，返回 null
+    });
+    it('应该处理空数组', () => {
+      expect(findMinMissingNum([])).toBe(1);
+    });
+    it('应该处理包含重复元素的数组', () => {
+      expect(findMinMissingNum([1, 1, 2, 2, 3])).toBe(4);
+    });
+    it('应该处理包含负数和0的数组', () => {
+      expect(findMinMissingNum([-3, -2, -1, 0, 1, 2])).toBe(3);
+    });
+    it('应该限制返回值在1-10范围内', () => {
+      // 所有1-10的数字都存在，应该返回 null
+      expect(findMinMissingNum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])).toBe(null);
+    });
+  });
+  describe('getSafeAreaPadding', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+    it('应该返回默认安全区域填充', () => {
+      // 模拟getCachedSystemInfo返回null
+      getCachedSystemInfo.mockReturnValue(null);
+      const result = getSafeAreaPadding();
+      expect(result).toEqual({
+        bottomHeight: 667,
+        bottomPadding: 20,
+        safeHeight: 667,
+        topPadding: 24
+      });
+    });
+    it('应该返回系统信息中的安全区域填充', () => {
+      // 模拟getCachedSystemInfo返回带有safeArea的系统信息
+
+      getCachedSystemInfo.mockReturnValue({
+        safeArea: {
+          top: 44,
+          right: 375,
+          bottom: 812,
+          left: 0,
+          width: 375,
+          height: 768
+        },
+        screenHeight: 812,
+        statusBarHeight: 44,
+        screenWidth: 375
+      });
+      const result = getSafeAreaPadding();
+      expect(result).toEqual({
+        bottomHeight: 812,
+        bottomPadding: 0,
+        safeHeight: 768,
+        topPadding: 44
+      });
+    });
+    it('应该处理safeArea不完整的情况', () => {
+      // 模拟getCachedSystemInfo返回不完整的safeArea
+
+      getCachedSystemInfo.mockReturnValue({
+        safeArea: {
+          top: 44,
+          // 缺少right
+          bottom: 812,
+          left: 0,
+          width: 375,
+          height: 768
+        },
+        screenHeight: 812,
+        statusBarHeight: 44,
+        screenWidth: 375
+      });
+      const result = getSafeAreaPadding();
+      expect(result).toEqual({
+        bottomHeight: 812,
+        bottomPadding: 0,
+        safeHeight: 768,
+        topPadding: 44
+      });
+    });
+  });
+  describe('timeStrToMinutes', () => {
+    it('应该将HH:mm格式的时间字符串转换为分钟数', () => {
+      expect(timeStrToMinutes('00:00')).toBe(0);
+      expect(timeStrToMinutes('01:00')).toBe(60);
+      expect(timeStrToMinutes('00:30')).toBe(30);
+      expect(timeStrToMinutes('01:30')).toBe(90);
+      expect(timeStrToMinutes('23:59')).toBe(1439);
+    });
+    it('应该处理格式不正确的时间字符串', () => {
+      expect(timeStrToMinutes('0:0')).toBe(0);
+      expect(timeStrToMinutes('1:0')).toBe(60);
+      expect(timeStrToMinutes('0:3')).toBe(3);
+      expect(timeStrToMinutes('1:3')).toBe(63);
+    });
+    it('应该处理非法输入', () => {
+      expect(timeStrToMinutes('')).toBe(0);
+      expect(timeStrToMinutes('invalid')).toBe(0);
+      expect(timeStrToMinutes('24:00')).toBe(0); // 超出有效范围
+      expect(timeStrToMinutes('23:60')).toBe(0); // 超出有效范围
+      expect(timeStrToMinutes('-1:00')).toBe(0); // 负数
+    });
+  });
+  describe('minutesToTimeStr', () => {
+    it('should convert minutes to time string', () => {
+      expect(minutesToTimeStr(90)).toBe('01:30');
+      expect(minutesToTimeStr(0)).toBe('00:00');
+      expect(minutesToTimeStr(undefined)).toBe('00:00');
+    });
+  });
+});

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

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

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

@@ -0,0 +1,98 @@
+import { SmartStorageAbility } from '@ray-js/panel-sdk';
+import { initStorage, getStorageIns } from '../storage';
+import { scheduleLogger } from '../ScheduleLogger';
+
+// Mock SmartStorageAbility
+jest.mock('@ray-js/panel-sdk', () => ({
+  SmartStorageAbility: jest.fn().mockImplementation(() => ({
+    init: jest.fn()
+  }))
+}));
+
+// Mock ScheduleLogger
+jest.mock('../ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn()
+  }
+}));
+describe('Storage Utils', () => {
+  beforeEach(() => {
+    // 清除所有模拟函数的调用记录
+    jest.clearAllMocks();
+    // 重置全局缓存
+    globalThis.__GCaches__ = {
+      SmartStorageAbility: {
+        get: jest.fn(),
+        set: jest.fn(),
+        remove: jest.fn(),
+        clear: jest.fn()
+      }
+    };
+    // 重置 storage 实例
+    getStorageIns.__storage = null;
+  });
+  describe('initStorage', () => {
+    it('应该成功初始化 storage', async () => {
+      const mockStorage = {
+        someMethod: jest.fn()
+      };
+      const mockInit = jest.fn().mockResolvedValue(mockStorage);
+      SmartStorageAbility.mockImplementation(() => ({
+        init: mockInit
+      }));
+      const result = await initStorage('test-device-id', 'test-group-id');
+      expect(result).toBe(true);
+      expect(mockInit).toHaveBeenCalledWith({
+        deviceId: 'test-device-id',
+        groupId: 'test-group-id'
+      });
+      expect(scheduleLogger.debug).toHaveBeenCalledWith('initStorage success:', mockStorage);
+    });
+    it('应该在初始化失败时返回 false', async () => {
+      const mockError = new Error('初始化失败');
+      const mockInit = jest.fn().mockRejectedValue(mockError);
+      SmartStorageAbility.mockImplementation(() => ({
+        init: mockInit
+      }));
+      const result = await initStorage('test-device-id', 'test-group-id');
+      expect(result).toBe(false);
+      expect(scheduleLogger.error).toHaveBeenCalledWith('initStorage failed:', mockError);
+    });
+  });
+  describe('getStorageIns', () => {
+    it('应该返回已初始化的 storage 实例', async () => {
+      const mockStorage = {
+        someMethod: jest.fn()
+      };
+      const mockInit = jest.fn().mockResolvedValue(mockStorage);
+      SmartStorageAbility.mockImplementation(() => ({
+        init: mockInit
+      }));
+      await initStorage('test-device-id', 'test-group-id');
+      const storage = getStorageIns();
+      expect(storage).toBe(mockStorage);
+      expect(scheduleLogger.warn).not.toHaveBeenCalled();
+    });
+    it('应该在 storage 未初始化时发出警告', async () => {
+      jest.resetModules();
+      jest.doMock('../ScheduleLogger', () => ({
+        scheduleLogger: {
+          debug: jest.fn(),
+          error: jest.fn(),
+          warn: jest.fn()
+        }
+      }));
+      const {
+        getStorageIns
+      } = await import('../storage');
+      const {
+        scheduleLogger
+      } = await import('../ScheduleLogger');
+      const storage = getStorageIns();
+      expect(storage).toBeNull();
+      expect(scheduleLogger.warn).toHaveBeenCalledWith('storage ins is null');
+    });
+  });
+});

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

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

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

@@ -0,0 +1,146 @@
+import { getTimeFormatStrByHourMins, getTimerStrByMinutes, getTimeNumByTimeStr, getPreOffsetTime, getPreOffsetTimeByHourMins, getBackwardOffsetTime, getBackwardOffsetTimeByHourMins } from '../time';
+describe('time', () => {
+  describe('getTimeFormatStrByHourMins', () => {
+    it('应该将小时和分钟转换为HH:mm格式字符串', () => {
+      expect(getTimeFormatStrByHourMins(0, 0)).toBe('00:00');
+      expect(getTimeFormatStrByHourMins(1, 0)).toBe('01:00');
+      expect(getTimeFormatStrByHourMins(0, 1)).toBe('00:01');
+      expect(getTimeFormatStrByHourMins(1, 1)).toBe('01:01');
+      expect(getTimeFormatStrByHourMins(12, 30)).toBe('12:30');
+      expect(getTimeFormatStrByHourMins(23, 59)).toBe('23:59');
+    });
+    it('应该处理超出范围的小时和分钟', () => {
+      expect(getTimeFormatStrByHourMins(24, 0)).toBe('00:00'); // 24小时应该转换为00
+      expect(getTimeFormatStrByHourMins(25, 0)).toBe('01:00'); // 25小时应该转换为01
+      expect(getTimeFormatStrByHourMins(0, 60)).toBe('01:00'); // 60分钟应该转换为1小时
+      expect(getTimeFormatStrByHourMins(0, 61)).toBe('01:01'); // 61分钟应该转换为1小时1分钟
+      expect(getTimeFormatStrByHourMins(23, 60)).toBe('00:00'); // 23小时60分钟应该转换为0小时0分钟
+    });
+    it('应该处理负数', () => {
+      expect(getTimeFormatStrByHourMins(-1, 0)).toBe('23:00'); // -1小时应该转换为23小时
+      expect(getTimeFormatStrByHourMins(0, -1)).toBe('23:59'); // -1分钟应该转换为23小时59分钟
+      expect(getTimeFormatStrByHourMins(-1, -1)).toBe('22:59'); // -1小时-1分钟应该转换为22小时59分钟
+    });
+  });
+  describe('getTimerStrByMinutes', () => {
+    it('应该将分钟数转换为HH:mm格式字符串', () => {
+      expect(getTimerStrByMinutes(0)).toBe('00:00');
+      expect(getTimerStrByMinutes(1)).toBe('00:01');
+      expect(getTimerStrByMinutes(60)).toBe('01:00');
+      expect(getTimerStrByMinutes(61)).toBe('01:01');
+      expect(getTimerStrByMinutes(90)).toBe('01:30');
+      expect(getTimerStrByMinutes(1439)).toBe('23:59'); // 一天的最后一分钟
+    });
+    it('应该处理超出一天的分钟数', () => {
+      expect(getTimerStrByMinutes(1440)).toBe('00:00'); // 一天的分钟数
+      expect(getTimerStrByMinutes(1441)).toBe('00:01'); // 一天加1分钟
+      expect(getTimerStrByMinutes(1500)).toBe('01:00'); // 一天加60分钟
+      expect(getTimerStrByMinutes(2880)).toBe('00:00'); // 两天的分钟数
+    });
+  });
+  describe('getTimeNumByTimeStr', () => {
+    it('应该将HH:mm格式字符串转换为分钟数', () => {
+      expect(getTimeNumByTimeStr('00:00')).toBe(0);
+      expect(getTimeNumByTimeStr('00:01')).toBe(1);
+      expect(getTimeNumByTimeStr('01:00')).toBe(60);
+      expect(getTimeNumByTimeStr('01:01')).toBe(61);
+      expect(getTimeNumByTimeStr('01:30')).toBe(90);
+      expect(getTimeNumByTimeStr('23:59')).toBe(1439);
+    });
+    it('应该处理格式不正确的时间字符串', () => {
+      expect(getTimeNumByTimeStr('0:0')).toBe(0);
+      expect(getTimeNumByTimeStr('0:1')).toBe(1);
+      expect(getTimeNumByTimeStr('1:0')).toBe(60);
+      expect(getTimeNumByTimeStr('1:1')).toBe(61);
+      expect(getTimeNumByTimeStr('1:30')).toBe(90);
+      expect(getTimeNumByTimeStr('23:59')).toBe(1439);
+    });
+    it('应该处理非法输入', () => {
+      expect(getTimeNumByTimeStr('')).toBe(0);
+      expect(getTimeNumByTimeStr('invalid')).toBe(0);
+      expect(getTimeNumByTimeStr('24:00')).toBe(0); // 超出有效范围
+      expect(getTimeNumByTimeStr('23:60')).toBe(0); // 超出有效范围
+      expect(getTimeNumByTimeStr('-1:00')).toBe(0); // 负数
+    });
+  });
+  describe('getPreOffsetTime', () => {
+    it('应该根据偏移量计算向前偏移的时间', () => {
+      expect(getPreOffsetTime('00:00', 0)).toBe('00:00'); // 无偏移
+      expect(getPreOffsetTime('00:00', 1)).toBe('23:59'); // 偏移1分钟
+      expect(getPreOffsetTime('00:00', 60)).toBe('23:00'); // 偏移1小时
+      expect(getPreOffsetTime('00:00', 90)).toBe('22:30'); // 偏移1小时30分钟
+      expect(getPreOffsetTime('12:30', 30)).toBe('12:00'); // 偏移30分钟
+      expect(getPreOffsetTime('12:30', 90)).toBe('11:00'); // 偏移1小时30分钟
+    });
+    it('应该处理大偏移量', () => {
+      expect(getPreOffsetTime('00:00', 1440)).toBe('00:00'); // 偏移1天
+      expect(getPreOffsetTime('00:00', 1441)).toBe('23:59'); // 偏移1天1分钟
+      expect(getPreOffsetTime('00:00', 2880)).toBe('00:00'); // 偏移2天
+    });
+    it('应该处理负偏移量（实际是向后偏移）', () => {
+      expect(getPreOffsetTime('00:00', -1)).toBe('00:01'); // 向后偏移1分钟
+      expect(getPreOffsetTime('00:00', -60)).toBe('01:00'); // 向后偏移1小时
+      expect(getPreOffsetTime('23:59', -1)).toBe('00:00'); // 向后偏移1分钟
+    });
+  });
+  describe('getPreOffsetTimeByHourMins', () => {
+    it('应该根据小时、分钟和偏移量计算向前偏移的时间', () => {
+      expect(getPreOffsetTimeByHourMins(0, 0, 0)).toBe('00:00'); // 无偏移
+      expect(getPreOffsetTimeByHourMins(0, 0, 1)).toBe('23:59'); // 偏移1分钟
+      expect(getPreOffsetTimeByHourMins(0, 0, 60)).toBe('23:00'); // 偏移1小时
+      expect(getPreOffsetTimeByHourMins(0, 0, 90)).toBe('22:30'); // 偏移1小时30分钟
+      expect(getPreOffsetTimeByHourMins(12, 30, 30)).toBe('12:00'); // 偏移30分钟
+      expect(getPreOffsetTimeByHourMins(12, 30, 90)).toBe('11:00'); // 偏移1小时30分钟
+    });
+    it('应该处理大偏移量', () => {
+      expect(getPreOffsetTimeByHourMins(0, 0, 1440)).toBe('00:00'); // 偏移1天
+      expect(getPreOffsetTimeByHourMins(0, 0, 1441)).toBe('23:59'); // 偏移1天1分钟
+      expect(getPreOffsetTimeByHourMins(0, 0, 2880)).toBe('00:00'); // 偏移2天
+    });
+    it('应该处理负偏移量（实际是向后偏移）', () => {
+      expect(getPreOffsetTimeByHourMins(0, 0, -1)).toBe('00:01'); // 向后偏移1分钟
+      expect(getPreOffsetTimeByHourMins(0, 0, -60)).toBe('01:00'); // 向后偏移1小时
+      expect(getPreOffsetTimeByHourMins(23, 59, -1)).toBe('00:00'); // 向后偏移1分钟
+    });
+  });
+  describe('getBackwardOffsetTime', () => {
+    it('应该根据偏移量计算向后偏移的时间', () => {
+      expect(getBackwardOffsetTime('00:00', 0)).toBe('00:00'); // 无偏移
+      expect(getBackwardOffsetTime('00:00', 1)).toBe('00:01'); // 偏移1分钟
+      expect(getBackwardOffsetTime('00:00', 60)).toBe('01:00'); // 偏移1小时
+      expect(getBackwardOffsetTime('00:00', 90)).toBe('01:30'); // 偏移1小时30分钟
+      expect(getBackwardOffsetTime('23:30', 30)).toBe('00:00'); // 偏移30分钟
+      expect(getBackwardOffsetTime('23:00', 90)).toBe('00:30'); // 偏移1小时30分钟
+    });
+    it('应该处理大偏移量', () => {
+      expect(getBackwardOffsetTime('00:00', 1440)).toBe('00:00'); // 偏移1天
+      expect(getBackwardOffsetTime('00:00', 1441)).toBe('00:01'); // 偏移1天1分钟
+      expect(getBackwardOffsetTime('00:00', 2880)).toBe('00:00'); // 偏移2天
+    });
+    it('应该处理负偏移量（实际是向前偏移）', () => {
+      expect(getBackwardOffsetTime('00:00', -1)).toBe('23:59'); // 向前偏移1分钟
+      expect(getBackwardOffsetTime('00:00', -60)).toBe('23:00'); // 向前偏移1小时
+      expect(getBackwardOffsetTime('00:01', -1)).toBe('00:00'); // 向前偏移1分钟
+    });
+  });
+  describe('getBackwardOffsetTimeByHourMins', () => {
+    it('应该根据小时、分钟和偏移量计算向后偏移的时间', () => {
+      expect(getBackwardOffsetTimeByHourMins(0, 0, 0)).toBe('00:00'); // 无偏移
+      expect(getBackwardOffsetTimeByHourMins(0, 0, 1)).toBe('00:01'); // 偏移1分钟
+      expect(getBackwardOffsetTimeByHourMins(0, 0, 60)).toBe('01:00'); // 偏移1小时
+      expect(getBackwardOffsetTimeByHourMins(0, 0, 90)).toBe('01:30'); // 偏移1小时30分钟
+      expect(getBackwardOffsetTimeByHourMins(23, 30, 30)).toBe('00:00'); // 偏移30分钟
+      expect(getBackwardOffsetTimeByHourMins(23, 0, 90)).toBe('00:30'); // 偏移1小时30分钟
+    });
+    it('应该处理大偏移量', () => {
+      expect(getBackwardOffsetTimeByHourMins(0, 0, 1440)).toBe('00:00'); // 偏移1天
+      expect(getBackwardOffsetTimeByHourMins(0, 0, 1441)).toBe('00:01'); // 偏移1天1分钟
+      expect(getBackwardOffsetTimeByHourMins(0, 0, 2880)).toBe('00:00'); // 偏移2天
+    });
+    it('应该处理负偏移量（实际是向前偏移）', () => {
+      expect(getBackwardOffsetTimeByHourMins(0, 0, -1)).toBe('23:59'); // 向前偏移1分钟
+      expect(getBackwardOffsetTimeByHourMins(0, 0, -60)).toBe('23:00'); // 向前偏移1小时
+      expect(getBackwardOffsetTimeByHourMins(0, 1, -1)).toBe('00:00'); // 向前偏移1分钟
+    });
+  });
+});

package/lib/utils/common.d.ts

@@ -0,0 +1,23 @@
+export declare const isIOS: () => boolean;
+export declare const isNum: (val: unknown) => boolean;
+/**
+ * 查找数组中缺失的最小正整数
+ * 函数的搜索范围限定为1到10之间如果在这个范围内所有数字都存在，则返回11
+ *
+ * @param arr 整数数组，可能包含正数、负数和零
+ * @returns 返回缺失的最小正整数，如果不存在，则返回 null
+ */
+export declare const findMinMissingNum: (arr: number[] | string[]) => number;
+export declare const getSafeAreaPadding: () => {
+    bottomPadding: number;
+    topPadding: number;
+    safeHeight: number;
+    bottomHeight: number;
+};
+export declare const timeStrToMinutes: (timeStr: string) => number;
+/**
+ * 将分钟数转换为时间字符串
+ * @param minutes 分钟数
+ * @returns 时间字符串，格式为 HH:mm
+ */
+export declare const minutesToTimeStr: (minutes: number) => string;

package/lib/utils/common.js

@@ -0,0 +1,109 @@
+import "core-js/modules/esnext.iterator.map.js";
+import { getCachedSystemInfo } from './getCachedSystemInfo';
+
+// 判断是否是iOS系统
+export const isIOS = () => {
+  var _getCachedSystemInfo;
+  return ((_getCachedSystemInfo = getCachedSystemInfo()) === null || _getCachedSystemInfo === void 0 || (_getCachedSystemInfo = _getCachedSystemInfo.platform) === null || _getCachedSystemInfo === void 0 ? void 0 : _getCachedSystemInfo.toLocaleLowerCase()) === 'ios';
+};
+export const isNum = val => {
+  if (val === null || val === undefined) return false;
+  const num = Number(val);
+  return typeof val === 'number' && !isNaN(num) && isFinite(num);
+};
+
+/**
+ * 查找数组中缺失的最小正整数
+ * 函数的搜索范围限定为1到10之间如果在这个范围内所有数字都存在，则返回11
+ *
+ * @param arr 整数数组，可能包含正数、负数和零
+ * @returns 返回缺失的最小正整数，如果不存在，则返回 null
+ */
+export const findMinMissingNum = arr => {
+  // 创建一个Set来存储数组中的元素，以实现快速查找
+  const numSet = new Set(arr.map(i => +i));
+
+  // 从 1 到 10 查找第一个不存在的数字
+  for (let i = 1; i <= 10; i++) {
+    // 如果当前数字不在Set中，则返回该数字
+    if (!numSet.has(i)) {
+      return i;
+    }
+  }
+
+  // 如果 1-10 都存在则返回 null
+  return null;
+};
+
+/**
+ * 获取屏幕安全区域
+ * @returns {
+ *  bottomPadding: number; // 底部距离的安全 padding 距离，单位：px
+ *  topPadding: number; // 顶部距离的安全 padding 距离，单位：px
+ *  safeHeight: number;
+ * }
+ */
+let safePadding = null;
+export const getSafeAreaPadding = () => {
+  if (safePadding) {
+    return safePadding;
+  }
+  try {
+    const systemInfo = getCachedSystemInfo();
+    const {
+      safeArea,
+      screenHeight,
+      statusBarHeight
+    } = systemInfo;
+    const bottomPadding = screenHeight - safeArea.bottom;
+    const _isIos = isIOS();
+    safePadding = {
+      bottomPadding,
+      topPadding: statusBarHeight,
+      safeHeight: _isIos ? safeArea.bottom : screenHeight - statusBarHeight,
+      bottomHeight: safeArea.bottom
+    };
+    return safePadding;
+  } catch (err) {
+    return {
+      bottomPadding: 20,
+      topPadding: 24,
+      safeHeight: 667,
+      bottomHeight: 667
+    };
+  }
+};
+
+// 将时间字符串转换为分钟数
+export const timeStrToMinutes = timeStr => {
+  try {
+    if (!timeStr || typeof timeStr !== 'string') {
+      return 0;
+    }
+    const parts = timeStr.split(':');
+    if (parts.length !== 2) {
+      return 0;
+    }
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+
+    // 验证时间范围
+    if (isNaN(hours) || isNaN(minutes) || hours < 0 || hours >= 24 || minutes < 0 || minutes >= 60) {
+      return 0;
+    }
+    return hours * 60 + minutes;
+  } catch (error) {
+    return 0;
+  }
+};
+
+/**
+ * 将分钟数转换为时间字符串
+ * @param minutes 分钟数
+ * @returns 时间字符串，格式为 HH:mm
+ */
+export const minutesToTimeStr = minutes => {
+  if (!minutes && minutes !== 0) return '00:00';
+  const hours = Math.floor(minutes / 60);
+  return `${hours.toString().padStart(2, '0')}:${(minutes % 60).toString().padStart(2, '0')}`;
+};

package/lib/utils/dpState.d.ts

@@ -0,0 +1,5 @@
+export declare const getDpState: (dpCode: string) => any;
+export declare const setDpState: (dpCode: string, dpValue: any) => void;
+export declare const clearDpState: () => void;
+export declare const getAllDpState: () => {};
+export declare const initDpState: (dpState?: Record<string, any>) => void;