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

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

@@ -0,0 +1,93 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useTimerReportDp, useTimerReportDpPull } from '../useTimerReportDp';
+import { useBaseLightDp, useFetchDpDataByMesh } from '../useBaseLightDp';
+import { useSupport } from '../useCommonSupport';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { timerReportParser } from '../../dpParser';
+import { scheduleLogger } from '../../utils/ScheduleLogger';
+// Mock dependencies
+jest.mock('../useBaseLightDp');
+jest.mock('../useCommonSupport');
+jest.mock('../../dpParser');
+jest.mock('../../utils/ScheduleLogger');
+describe('useTimerReportDp', () => {
+  const mockDpValue = [{
+    id: '1',
+    status: true
+  }];
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockDpValue,
+      updateDp: jest.fn()
+    });
+    useSupport.mockReturnValue({
+      isSupportDp: jest.fn().mockReturnValue(true)
+    });
+    timerReportParser.formatter.mockImplementation(data => data);
+    timerReportParser.parser.mockImplementation(data => data);
+  });
+  it('should return correct initial values', () => {
+    const {
+      result
+    } = renderHook(() => useTimerReportDp());
+    expect(result.current.isSupport).toBe(true);
+    expect(result.current.dpValue).toEqual(mockDpValue);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should call updateDp with formatted data', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockDpValue,
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useTimerReportDp());
+    act(() => {
+      result.current.updateDp(mockDpValue);
+    });
+    expect(timerReportParser.formatter).toHaveBeenCalledWith(mockDpValue);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockDpValue);
+  });
+  it('should parse string dpValue correctly', () => {
+    const stringDpValue = JSON.stringify(mockDpValue);
+    useBaseLightDp.mockReturnValue({
+      dpValue: stringDpValue,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useTimerReportDp());
+    expect(timerReportParser.parser).toHaveBeenCalledWith(stringDpValue);
+  });
+});
+describe('useTimerReportDpPull', () => {
+  const mockRefresh = jest.fn();
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useFetchDpDataByMesh.mockReturnValue({
+      refresh: mockRefresh
+    });
+  });
+  it('should return refresh function', () => {
+    const {
+      result
+    } = renderHook(() => useTimerReportDpPull());
+    expect(typeof result.current.refresh).toBe('function');
+    expect(scheduleLogger.debug).toHaveBeenCalledWith('useTimerReportDpPull 执行');
+  });
+  it('should call refresh when refresh function is called', () => {
+    const {
+      result
+    } = renderHook(() => useTimerReportDpPull());
+    act(() => {
+      result.current.refresh();
+    });
+    expect(mockRefresh).toHaveBeenCalled();
+  });
+  it('should use correct dpCode', () => {
+    renderHook(() => useTimerReportDpPull());
+    expect(useFetchDpDataByMesh).toHaveBeenCalledWith([scheduleDpCodes.TIMER_REPORT]);
+  });
+});

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

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

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

@@ -0,0 +1,110 @@
+import { renderHook } from '@testing-library/react-hooks';
+import { useSupportLocalTimer, useSupportCloudTimer, useTimerSupport } from '../useTimerSupport';
+import { useCommonSupport, useSupport } from '../useCommonSupport';
+import { scheduleDpCodes } from '../../config/dpCodes';
+
+// Mock dependencies
+jest.mock('../useCommonSupport');
+describe('useTimerSupport Hooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('useSupportLocalTimer', () => {
+    it('should return correct support status for non-group device', () => {
+      useCommonSupport.mockReturnValue({
+        isReady: true,
+        isSupport: true
+      });
+      const {
+        result
+      } = renderHook(() => useSupportLocalTimer());
+      expect(result.current).toEqual({
+        isReady: true,
+        isSupport: true
+      });
+      expect(useCommonSupport).toHaveBeenCalledWith([scheduleDpCodes.LOCAL_TIMER, scheduleDpCodes.RTC_TIMER, scheduleDpCodes.STRIP_LOCAL_TIMER], []);
+    });
+    it('should return false support for group device', () => {
+      useSupport.mockReturnValue({
+        isGroupDevice: () => true
+      });
+      useCommonSupport.mockReturnValue({
+        isReady: true,
+        isSupport: true
+      });
+      const {
+        result
+      } = renderHook(() => useSupportLocalTimer());
+      expect(result.current).toEqual({
+        isReady: true,
+        isSupport: false
+      });
+    });
+    it('should handle custom dpCodeList', () => {
+      const customDpCodeList = ['custom_dp_1', 'custom_dp_2'];
+      useSupport.mockReturnValue({
+        isGroupDevice: () => false
+      });
+      useCommonSupport.mockReturnValue({
+        isReady: true,
+        isSupport: true
+      });
+      renderHook(() => useSupportLocalTimer(customDpCodeList));
+      expect(useCommonSupport).toHaveBeenCalledWith([scheduleDpCodes.LOCAL_TIMER, scheduleDpCodes.RTC_TIMER, scheduleDpCodes.STRIP_LOCAL_TIMER], customDpCodeList);
+    });
+  });
+  describe('useSupportCloudTimer', () => {
+    it('should return cloud timer support status', () => {
+      useSupport.mockReturnValue({
+        isSupportCloudTimer: () => true
+      });
+      const {
+        result
+      } = renderHook(() => useSupportCloudTimer());
+      expect(result.current).toBe(true);
+    });
+    it('should return false when cloud timer is not supported', () => {
+      useSupport.mockReturnValue({
+        isSupportCloudTimer: () => false
+      });
+      const {
+        result
+      } = renderHook(() => useSupportCloudTimer());
+      expect(result.current).toBe(false);
+    });
+  });
+  describe('useTimerSupport', () => {
+    it('should return true when either local or cloud timer is supported', () => {
+      useSupport.mockReturnValue({
+        isGroupDevice: () => false,
+        isSupportCloudTimer: () => true
+      });
+      useCommonSupport.mockReturnValue({
+        isReady: true,
+        isSupport: true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerSupport());
+      expect(result.current).toEqual({
+        isSupport: true
+      });
+    });
+    it('should return false when neither local nor cloud timer is supported', () => {
+      useSupport.mockReturnValue({
+        isGroupDevice: () => true,
+        isSupportCloudTimer: () => false
+      });
+      useCommonSupport.mockReturnValue({
+        isReady: true,
+        isSupport: true
+      });
+      const {
+        result
+      } = renderHook(() => useTimerSupport());
+      expect(result.current).toEqual({
+        isSupport: false
+      });
+    });
+  });
+});

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

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

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

@@ -0,0 +1,129 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useWakeUpDp } from '../useWakeUpDp';
+import { useBaseLightDp } from '../useBaseLightDp';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { getWakeUpParser } from '../../dpParser/wakeup';
+// Mock dependencies
+jest.mock('../useBaseLightDp');
+jest.mock('../../dpParser/wakeup');
+describe('useWakeUpDp', () => {
+  const mockWakeUpData = {
+    version: 1,
+    number: 1,
+    nodes: [{
+      onOff: true,
+      loops: '0000000',
+      step: 1,
+      hour: 8,
+      minute: 0,
+      hue: 0,
+      saturation: 100,
+      value: 100,
+      brightness: 100,
+      temperature: 5000,
+      duration: 1,
+      index: 0,
+      time: '08:00'
+    }]
+  };
+  const mockWakeUpDataSigmesh = {
+    version: 1,
+    dataMode: '01',
+    length: 1,
+    nodes: [{
+      onOff: true,
+      loops: '0000000',
+      step: 1,
+      hour: 8,
+      minute: 0,
+      brightness: 100,
+      temperature: 5000,
+      duration: 1,
+      index: 0,
+      time: '08:00'
+    }]
+  };
+  const mockParser = {
+    formatter: jest.fn(),
+    parser: jest.fn()
+  };
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockWakeUpData,
+      updateDp: jest.fn()
+    });
+    getWakeUpParser.mockReturnValue(mockParser);
+    mockParser.formatter.mockImplementation(data => data);
+    mockParser.parser.mockImplementation(data => data);
+  });
+  it('should return correct initial values with TWakeUpData', () => {
+    const {
+      result
+    } = renderHook(() => useWakeUpDp());
+    expect(result.current.dpValue).toEqual(mockWakeUpData);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should return correct initial values with TWakeUpDataSigmesh', () => {
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockWakeUpDataSigmesh,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useWakeUpDp());
+    expect(result.current.dpValue).toEqual(mockWakeUpDataSigmesh);
+    expect(typeof result.current.updateDp).toBe('function');
+  });
+  it('should call updateDp with formatted data for TWakeUpData', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockWakeUpData,
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useWakeUpDp());
+    act(() => {
+      result.current.updateDp(mockWakeUpData);
+    });
+    expect(mockParser.formatter).toHaveBeenCalledWith(mockWakeUpData);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockWakeUpData);
+  });
+  it('should call updateDp with formatted data for TWakeUpDataSigmesh', () => {
+    const mockUpdateDp = jest.fn();
+    useBaseLightDp.mockReturnValue({
+      dpValue: mockWakeUpDataSigmesh,
+      updateDp: mockUpdateDp
+    });
+    const {
+      result
+    } = renderHook(() => useWakeUpDp());
+    act(() => {
+      result.current.updateDp(mockWakeUpDataSigmesh);
+    });
+    expect(mockParser.formatter).toHaveBeenCalledWith(mockWakeUpDataSigmesh);
+    expect(mockUpdateDp).toHaveBeenCalledWith(mockWakeUpDataSigmesh);
+  });
+  it('should parse string dpValue correctly', () => {
+    const stringDpValue = JSON.stringify(mockWakeUpData);
+    useBaseLightDp.mockReturnValue({
+      dpValue: stringDpValue,
+      updateDp: jest.fn()
+    });
+    const {
+      result
+    } = renderHook(() => useWakeUpDp());
+    expect(mockParser.parser).toHaveBeenCalledWith(stringDpValue);
+    expect(result.current.dpValue).toEqual(JSON.stringify(mockWakeUpData));
+  });
+  it('should use correct dpCode', () => {
+    renderHook(() => useWakeUpDp());
+    expect(useBaseLightDp).toHaveBeenCalledWith(scheduleDpCodes.WAKE_UP_MODE);
+  });
+  it('should handle custom dpCode', () => {
+    const customDpCode = scheduleDpCodes.WAKE_UP_MODE;
+    renderHook(() => useWakeUpDp(customDpCode));
+    expect(useBaseLightDp).toHaveBeenCalledWith(customDpCode);
+  });
+});

package/lib/hooks/useBaseLightDp.d.ts

@@ -0,0 +1,21 @@
+import { DpValue } from '../types';
+type TDpRes<T> = {
+    dpValue: T | null;
+    /**
+     * 更新 dp 函数
+     * @param value dp 值
+     * @param errCallback 错误回调
+     */
+    updateDp: (value: DpValue, errCallback?: (err: Error) => void) => void;
+};
+export declare function useBaseLightDp<T>(dpCode: string, defaultDpValue?: T): TDpRes<T>;
+export declare const getDpDataByMesh: (dpCodes?: string[]) => void;
+/**
+ * 主动拉取 dp 数据
+ * @param dpCodes dpCode 数组
+ * @returns refresh 刷新 dp 数据
+ */
+export declare const useFetchDpDataByMesh: (dpCodes: string[]) => {
+    refresh: () => void;
+};
+export {};

package/lib/hooks/useBaseLightDp.js

@@ -0,0 +1,165 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.map.js";
+/* eslint-disable no-console */
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { isEqual } from 'lodash-es';
+import { queryDps } from '@ray-js/ray';
+import { scheduleLogger } from '../utils/ScheduleLogger';
+import { devIdOrGroupIdCache } from '../utils/ScheduleCache';
+import { updateDeviceDp } from '../conflict/updateDeviceDp';
+import { isInitFn, useSupport } from '../hooks/useCommonSupport';
+import { getDpIdByDpCode } from '../utils/ScheduleUtils';
+import { emitter } from '../utils/ScheduleEmit';
+import { DP_CHANGE_EVENT_KEY } from '../constant';
+import { getDpState, setDpState } from '../utils/dpState';
+export function useBaseLightDp(dpCode, defaultDpValue) {
+  const {
+    devId: deviceId,
+    groupId
+  } = devIdOrGroupIdCache.get();
+  const [dpValue, setDpValue] = useState(defaultDpValue !== null && defaultDpValue !== void 0 ? defaultDpValue : null);
+  const isInit = isInitFn();
+  const preDpValue = useRef(null);
+  const callback = useCallback(dpData => {
+    if (!isInit) {
+      scheduleLogger.warn('useBaseLightDp callback is not init');
+      return;
+    }
+    let dpId = dpCode;
+    // eslint-disable-next-line no-self-compare
+    if (+dpCode !== +dpCode) {
+      dpId = getDpIdByDpCode(dpCode);
+    }
+    if (dpData.deviceId === deviceId && dpId in dpData.dps) {
+      scheduleLogger.debug(`${dpCode} ==> emitter will changed:`, dpData);
+      const _dpValue = dpData.dps[dpId];
+      if (isEqual(preDpValue.current, _dpValue)) {
+        scheduleLogger.warn(`emitter 重复触发 ${DP_CHANGE_EVENT_KEY}, 已过滤`, dpData);
+        return;
+      }
+      scheduleLogger.debug(`${dpCode} ==> emitter changed:`, preDpValue.current, _dpValue);
+      preDpValue.current = _dpValue;
+      setDpState(dpCode, _dpValue);
+      setDpValue(_dpValue);
+    }
+  }, [deviceId, groupId, isInit, dpCode]);
+  const fetchRef = useRef(false);
+  useEffect(() => {
+    emitter.off(DP_CHANGE_EVENT_KEY, callback);
+    emitter.on(DP_CHANGE_EVENT_KEY, callback);
+    return () => {
+      scheduleLogger.warn(`${DP_CHANGE_EVENT_KEY} off`);
+      emitter.off(DP_CHANGE_EVENT_KEY, callback);
+    };
+  }, [deviceId, groupId, isInit, dpCode]);
+
+  // 获取设备类型和dp值
+  useEffect(() => {
+    if (!isInit) {
+      return;
+    }
+    // 首次进入拉取一次， 后续通过事件获取最新的 dp 数据
+    if (fetchRef.current) {
+      return;
+    }
+    fetchRef.current = true;
+    (async () => {
+      const dpValue = getDpState(dpCode);
+      fetchRef.current = true;
+      dpValue !== undefined && setDpValue(dpValue);
+    })();
+  }, [deviceId, groupId, dpCode, isInit]);
+
+  // 更新dp值
+
+  return {
+    dpValue,
+    updateDp: (value, errCallback) => {
+      try {
+        const dpId = getDpIdByDpCode(dpCode);
+        if (!dpId) {
+          scheduleLogger.error('updateDp error: ', dpCode, '未匹配到 dpId');
+          return;
+        }
+        const dps = {
+          [dpId]: value
+        };
+        scheduleLogger.debug('updateDp dps:', dps);
+        updateDeviceDp(deviceId, groupId, dps);
+      } catch (error) {
+        scheduleLogger.error('Failed to update dp:', error);
+        errCallback && errCallback(error);
+      }
+    }
+  };
+}
+
+// 查询 mesh 设备的 DP
+export const getDpDataByMesh = function () {
+  let dpCodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  if (!Array.isArray(dpCodes)) {
+    scheduleLogger.error('getDpDataByMesh: 参数dpCodes必须是数组');
+    return;
+  }
+  if (dpCodes.length >= 5) {
+    scheduleLogger.warn('getDpDataByMesh: 单次查询 dp 数过多，dp 可能响应不及时，请分次查询');
+  }
+  scheduleLogger.debug('getDpDataByMesh 开始查询DP参数 dpCodes:', dpCodes);
+  const deviceData = devIdOrGroupIdCache.get();
+  const deviceId = deviceData === null || deviceData === void 0 ? void 0 : deviceData.devId;
+  if (!deviceId) {
+    scheduleLogger.error('getDpDataByMesh: 未能获取到deviceId');
+    return;
+  }
+  const dpIds = dpCodes.map(item => getDpIdByDpCode(item)).filter(i => !!i).map(String); // 简化字符串转换
+
+  if (dpIds.length === 0) {
+    scheduleLogger.warn('getDpDataByMesh', dpCodes, '未匹配到 dp');
+    return;
+  }
+  scheduleLogger.debug('getDpDataByMesh 查询DP转换后参数 dpIds:', dpIds);
+  try {
+    queryDps({
+      deviceId,
+      dpIds,
+      success: e => {
+        scheduleLogger.debug('getDpDataByMesh 查询DP参数 success:', e);
+      },
+      fail: err => {
+        scheduleLogger.warn('getDpDataByMesh 查询DP参数 fail:', err);
+      }
+    });
+  } catch (error) {
+    scheduleLogger.error('getDpDataByMesh 调用失败:', error);
+  }
+};
+/**
+ * 主动拉取 dp 数据
+ * @param dpCodes dpCode 数组
+ * @returns refresh 刷新 dp 数据
+ */
+export const useFetchDpDataByMesh = dpCodes => {
+  const support = useSupport();
+  const getDpDataByMeshFn = () => {
+    const isSigMeshDevice = support === null || support === void 0 ? void 0 : support.isSigMeshDevice();
+    if (!isSigMeshDevice) {
+      scheduleLogger.info('useFetchDpDataByMesh 当前设备为', support === null || support === void 0 ? void 0 : support.deviceType, ' 只支持 sigmesh 设备');
+      return;
+    }
+    scheduleLogger.debug('getDpDataByMeshFn get:', dpCodes);
+    getDpDataByMesh(dpCodes);
+  };
+  useEffect(() => {
+    const isSigMeshDevice = support === null || support === void 0 ? void 0 : support.isSigMeshDevice();
+    if (!isSigMeshDevice) {
+      scheduleLogger.info('useFetchDpDataByMesh 当前设备为', support === null || support === void 0 ? void 0 : support.deviceType, ' 只支持 sigmesh 设备');
+      return;
+    }
+    scheduleLogger.debug('useFetchDpDataByMesh get:', dpCodes);
+    getDpDataByMeshFn();
+  }, [dpCodes.join(','), support]);
+  return {
+    refresh: getDpDataByMeshFn
+  };
+};

package/lib/hooks/useCommon.d.ts

@@ -0,0 +1,29 @@
+export declare enum Themes {
+    dark = "dark",
+    light = "light"
+}
+export declare enum Orientation {
+    portrait = "portrait",
+    landscape = "landscape"
+}
+/**
+ * 获取手机系统时间制式
+ */
+export declare const useHourType: () => {
+    is12Hour: boolean;
+};
+/**
+ * 获取手机屏幕底部安全区域高度
+ */
+export declare const useSafeArea: () => number;
+/**
+ * 获取手机当前使用的语言
+ * @returns string // default: en
+ */
+export declare const useLanguage: () => string;
+export declare const useIsIOS: () => boolean;
+/**
+ * 隐藏菜单按钮
+ * @param returnShowMenu 返回页面后是否隐藏按钮
+ */
+export declare const useHideMenu: () => void;

package/lib/hooks/useCommon.js

@@ -0,0 +1,59 @@
+import { useEffect, useRef } from 'react';
+import { hideMenuButton } from '@ray-js/ray';
+import { getCachedSystemInfo } from '../utils/getCachedSystemInfo';
+export let Themes = /*#__PURE__*/function (Themes) {
+  Themes["dark"] = "dark";
+  Themes["light"] = "light";
+  return Themes;
+}({});
+export let Orientation = /*#__PURE__*/function (Orientation) {
+  Orientation["portrait"] = "portrait";
+  Orientation["landscape"] = "landscape";
+  return Orientation;
+}({});
+
+/**
+ * 获取手机系统时间制式
+ */
+export const useHourType = () => {
+  var _systemInfoRef$curren;
+  const systemInfoRef = useRef(getCachedSystemInfo());
+  const is24Hour = systemInfoRef === null || systemInfoRef === void 0 || (_systemInfoRef$curren = systemInfoRef.current) === null || _systemInfoRef$curren === void 0 ? void 0 : _systemInfoRef$curren.is24Hour;
+  return {
+    is12Hour: !is24Hour
+  };
+};
+
+/**
+ * 获取手机屏幕底部安全区域高度
+ */
+export const useSafeArea = () => {
+  var _systemInfoRef$curren2;
+  const systemInfoRef = useRef(getCachedSystemInfo());
+  return (systemInfoRef === null || systemInfoRef === void 0 || (_systemInfoRef$curren2 = systemInfoRef.current) === null || _systemInfoRef$curren2 === void 0 ? void 0 : _systemInfoRef$curren2.statusBarHeight) || 24;
+};
+
+/**
+ * 获取手机当前使用的语言
+ * @returns string // default: en
+ */
+export const useLanguage = () => {
+  var _systemInfoRef$curren3;
+  const systemInfoRef = useRef(getCachedSystemInfo());
+  return (systemInfoRef === null || systemInfoRef === void 0 || (_systemInfoRef$curren3 = systemInfoRef.current) === null || _systemInfoRef$curren3 === void 0 ? void 0 : _systemInfoRef$curren3.language) || 'en';
+};
+export const useIsIOS = () => {
+  var _systemInfoRef$curren4;
+  const systemInfoRef = useRef(getCachedSystemInfo());
+  return (systemInfoRef === null || systemInfoRef === void 0 || (_systemInfoRef$curren4 = systemInfoRef.current) === null || _systemInfoRef$curren4 === void 0 || (_systemInfoRef$curren4 = _systemInfoRef$curren4.platform) === null || _systemInfoRef$curren4 === void 0 ? void 0 : _systemInfoRef$curren4.toLocaleLowerCase()) === 'ios';
+};
+
+/**
+ * 隐藏菜单按钮
+ * @param returnShowMenu 返回页面后是否隐藏按钮
+ */
+export const useHideMenu = () => {
+  useEffect(() => {
+    hideMenuButton();
+  }, []);
+};

package/lib/hooks/useCommonSupport.d.ts

@@ -0,0 +1,25 @@
+import { Support } from '../utils/ScheduleSupport';
+export declare const useSupport: () => Support | null;
+type TScheduleInitState = {
+    isReady: boolean;
+};
+export declare const resetIsInit: () => void;
+export declare const useScheduleInit: (props: {
+    devId: string;
+    groupId?: string;
+}) => TScheduleInitState;
+export declare const getSupportIns: () => Support;
+export declare const isInitFn: () => boolean;
+export declare const useInit: () => boolean;
+/**
+ * @description: 判断是否支持某个功能 通过dpCode 来判断
+ * @param defaultCodes: 默认检测的 dpCode
+ * @param dpCodeList: dpCode 列表 string[], 非必填，默认为 [], 会检测标准计划 dp，如果不为 []，则检测 dpCodeList 中的 dp 支持情况
+ * @param checkType: 检测类型，every 必须支持 dpCodeList或defaultCodes 中所有的 dp 值，some 为支持其中一个即可。
+ * @return boolean
+ */
+export declare const useCommonSupport: (defaultCodes: string[], dpCodeList?: string[], checkType?: 'every' | 'some') => {
+    isReady: boolean;
+    isSupport: boolean;
+};
+export {};