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

package/lib/hooks/useCommonSupport.js

@@ -0,0 +1,241 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.every.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.some.js";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { getDeviceInfo, getGroupDpsInfos, onDpDataChange, registerDeviceListListener } from '@ray-js/ray';
+import { Support } from '../utils/ScheduleSupport';
+import { useTimerContext } from '../context/timer/context';
+import { scheduleLogger, scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+import { getTimerListWithFlush } from './useTimerOperateLocal';
+import { emitter } from '../utils/ScheduleEmit';
+import { initStorage } from '../utils/storage';
+import { DP_CHANGE_EVENT_KEY } from '../constant';
+import { initDpState } from '../utils/dpState';
+import { getDpCodeByDpId } from '../utils/ScheduleUtils';
+// Support 实例缓存
+let supportIns = {
+  isReady: false,
+  support: null
+};
+
+// Support hooks
+export const useSupport = () => {
+  const [_support, setSupport] = useState(supportIns.support);
+  useEffect(() => {
+    const callback = () => {
+      supportIns.support && setSupport(supportIns.support);
+    };
+    emitter.on('initDone', callback);
+    return () => {
+      emitter.off('initDone', callback);
+    };
+  }, []);
+  return _support || supportIns.support;
+};
+let _isInit = false;
+
+// 添加resetIsInit函数
+export const resetIsInit = () => {
+  _isInit = false;
+  supportIns = {
+    isReady: false,
+    support: null
+  };
+};
+export const useScheduleInit = props => {
+  const [scheduleState, setScheduleState] = useState(supportIns);
+  const {
+    dispatch,
+    actions
+  } = useTimerContext();
+  const callbackRef = useRef(() => {
+    ScheduleLogger.info('getTimerListWithFlush run');
+    getTimerListWithFlush(dispatch, actions);
+  });
+  useEffect(() => {
+    ScheduleLogger.info('timerReportFlushList 事件监听');
+    // 监听 timerReportFlushList 事件，当 timer_report dp 变化时，触发刷新 timerList
+    emitter.off('timerReportFlushList', callbackRef.current);
+    emitter.on('timerReportFlushList', callbackRef.current);
+    return () => {
+      _isInit = false;
+      emitter.off('timerReportFlushList', callbackRef.current);
+    };
+  }, []);
+
+  // eslint-disable-next-line consistent-return
+  useEffect(() => {
+    if (_isInit) {
+      return;
+    }
+    if (props.devId) {
+      registerDeviceListListener({
+        deviceIdList: [props.devId],
+        success: () => {
+          // 监听dp值变化 并触发
+
+          if (_isInit) {
+            ScheduleLogger.warn('useSupport: support is already initialized');
+            return;
+          }
+          onDpDataChange(res => {
+            if (!(res !== null && res !== void 0 && res.dps)) {
+              ScheduleLogger.warn(`useScheduleInit fail ${DP_CHANGE_EVENT_KEY}`, res);
+              return;
+            }
+            ScheduleLogger.info(`useScheduleInit ${DP_CHANGE_EVENT_KEY}`, res);
+            emitter.emit(DP_CHANGE_EVENT_KEY, {
+              deviceId: res.devId || res.deviceId,
+              dps: res === null || res === void 0 ? void 0 : res.dps
+            });
+          });
+        }
+      });
+    }
+  }, [_isInit, actions]);
+  useEffect(() => {
+    if (!props.devId && !props.groupId) {
+      ScheduleLogger.warn('useSupport: devId or groupId is required');
+      return;
+    }
+    scheduleLogger.warn('useSupport: panelConfig is initialized');
+    const newProps = _objectSpread({}, props);
+    if (_isInit) {
+      ScheduleLogger.warn('useSupport: support is already initialized');
+      return;
+    }
+    const support = new Support(newProps);
+    ScheduleLogger.warn('useSupport initStorage props: ', props);
+    const promiseList = Promise.all([initStorage(props.devId, props.groupId), support.init()]);
+    promiseList.then(() => {
+      if (props.groupId) {
+        // 获取群组 dp 数据
+        getGroupDpsInfos(props.groupId).then(res => {
+          scheduleLogger.debug('getGroupDpsInfos res', res);
+          res && Object.keys(res).length && initDpState(res);
+          supportIns = {
+            isReady: true,
+            support
+          };
+          emitter.emit('initDone');
+          _isInit = true;
+          ScheduleLogger.debug('useSupport: support init success', true);
+          setScheduleState({
+            isReady: true
+          });
+        }).catch(err => {
+          scheduleLogger.error('Failed to get group info groupId:', props.groupId);
+          scheduleLogger.error('Failed to get group info err:', err);
+        });
+      } else {
+        // 获取单设备 dp 数据
+        getDeviceInfo({
+          deviceId: props.devId,
+          success(res) {
+            const {
+              dps = {}
+            } = res || {};
+            const dpMap = {};
+            scheduleLogger.debug('getDeviceInfo res', res);
+            Object.keys(dps).forEach(dpId => {
+              const dpCode = getDpCodeByDpId(dpId);
+              dpMap[dpCode] = dps[dpId];
+            });
+            Object.keys(dpMap).length && initDpState(dpMap);
+            supportIns = {
+              isReady: true,
+              support
+            };
+            emitter.emit('initDone');
+            _isInit = true;
+            ScheduleLogger.debug('useSupport: support init success', true);
+            setScheduleState({
+              isReady: true
+            });
+          },
+          fail(err) {
+            scheduleLogger.error('Failed to get device info deviceId:', props.devId);
+            scheduleLogger.error('Failed to get device info err:', err);
+          }
+        });
+      }
+    }).catch(err => {
+      ScheduleLogger.error('useSupport: support init failed: ', err);
+      setScheduleState({
+        isReady: false
+      });
+    });
+  }, [props.devId, props.groupId]);
+  return scheduleState;
+};
+
+// 获取 Support 实例
+export const getSupportIns = () => {
+  var _supportIns;
+  if (!((_supportIns = supportIns) !== null && _supportIns !== void 0 && _supportIns.isReady)) {
+    ScheduleLogger.error('getSupportIns: support init failed, please call useScheduleInit first');
+    return supportIns.support;
+  }
+  return supportIns.support;
+};
+
+// 判断是否初始化
+export const isInitFn = () => {
+  return _isInit;
+};
+export const useInit = () => {
+  const [isInit, setIsInit] = useState(_isInit);
+  useEffect(() => {
+    const callback = () => {
+      scheduleLogger.info('useInit: initDone');
+      setIsInit(true);
+    };
+    emitter.on('initDone', callback);
+    return () => {
+      emitter.off('initDone', callback);
+    };
+  }, []);
+  return isInit || _isInit;
+};
+
+/**
+ * @description: 判断是否支持某个功能 通过dpCode 来判断
+ * @param defaultCodes: 默认检测的 dpCode
+ * @param dpCodeList: dpCode 列表 string[], 非必填，默认为 [], 会检测标准计划 dp，如果不为 []，则检测 dpCodeList 中的 dp 支持情况
+ * @param checkType: 检测类型，every 必须支持 dpCodeList或defaultCodes 中所有的 dp 值，some 为支持其中一个即可。
+ * @return boolean
+ */
+export const useCommonSupport = function (defaultCodes) {
+  let dpCodeList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  let checkType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'some';
+  const support = useSupport();
+  const isSupport = useMemo(() => {
+    if (!support) {
+      return false;
+    }
+    let _isSupport = false;
+    if (dpCodeList.length === 0) {
+      const _dpCodeList = defaultCodes;
+      if (checkType === 'some') {
+        _isSupport = _dpCodeList.some(_dpCode => support.isSupportDp(_dpCode));
+      } else if (checkType === 'every') {
+        _isSupport = _dpCodeList.every(_dpCode => support.isSupportDp(_dpCode));
+      }
+      // 默认检测本地定时 DP
+      return _isSupport;
+    }
+    // 自定义检测本地 定时 DP
+    if (checkType === 'some') {
+      _isSupport = dpCodeList.some(_dpCode => support.isSupportDp(_dpCode));
+    } else if (checkType === 'every') {
+      _isSupport = dpCodeList.every(_dpCode => support.isSupportDp(_dpCode));
+    }
+    return _isSupport;
+  }, [JSON.stringify(dpCodeList), checkType, JSON.stringify(defaultCodes), support]);
+  return {
+    isReady: true,
+    isSupport
+  };
+};

package/lib/hooks/useCountdownDp.d.ts

@@ -0,0 +1,13 @@
+import { DpValue } from '../types';
+export declare function useCountdownDp(dpCode?: "countdown"): {
+    dpValue: DpValue | null;
+    updateDp: (value: DpValue) => void;
+};
+/**
+ * 主动拉取倒计时dp数据
+ * @param countdownCode 倒计时dpCode
+ * @returns refresh 函数 刷新dp数据
+ */
+export declare const useCountdownDpPull: (countdownCode?: "countdown") => {
+    refresh: () => void;
+};

package/lib/hooks/useCountdownDp.js

@@ -0,0 +1,28 @@
+import { useBaseLightDp, useFetchDpDataByMesh } from './useBaseLightDp';
+import { scheduleDpCodes } from '../config/dpCodes';
+export function useCountdownDp() {
+  let dpCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.COUNTDOWN;
+  const {
+    dpValue,
+    updateDp
+  } = useBaseLightDp(dpCode);
+  return {
+    dpValue,
+    updateDp
+  };
+}
+
+/**
+ * 主动拉取倒计时dp数据
+ * @param countdownCode 倒计时dpCode
+ * @returns refresh 函数 刷新dp数据
+ */
+export const useCountdownDpPull = function () {
+  let countdownCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.COUNTDOWN;
+  const {
+    refresh
+  } = useFetchDpDataByMesh([countdownCode]);
+  return {
+    refresh
+  };
+};

package/lib/hooks/useCountdownSupport.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @description: 判断是否支持倒计时功能
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {isReady, isSupport}
+ */
+export declare const useCountdownSupport: (dpCodeList?: string[]) => {
+    isReady: boolean;
+    isSupport: boolean;
+};

package/lib/hooks/useCountdownSupport.js

@@ -0,0 +1,13 @@
+import { scheduleDpCodes } from '../config/dpCodes';
+import { useCommonSupport } from './useCommonSupport';
+
+/**
+ * @description: 判断是否支持倒计时功能
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {isReady, isSupport}
+ */
+export const useCountdownSupport = function () {
+  let dpCodeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  const support = useCommonSupport([scheduleDpCodes.COUNTDOWN], dpCodeList);
+  return support;
+};

package/lib/hooks/useCycleDp.d.ts

@@ -0,0 +1,7 @@
+import { TCycleData } from '../types';
+type TDpRes = {
+    dpValue: TCycleData;
+    updateDp: (value: TCycleData) => void;
+};
+export declare function useCycleDp(dpCode?: "cycle_timing"): TDpRes;
+export {};

package/lib/hooks/useCycleDp.js

@@ -0,0 +1,21 @@
+import { useMemo } from 'react';
+import { useBaseLightDp } from './useBaseLightDp';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { getCycleParser } from '../dpParser/cycle';
+export function useCycleDp() {
+  let dpCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.CYCLE_TIMING;
+  const {
+    dpValue,
+    updateDp
+  } = useBaseLightDp(dpCode);
+  const cycleParser = getCycleParser();
+  const _dpValue = useMemo(() => {
+    return cycleParser.parser(dpValue);
+  }, [dpValue]);
+  return {
+    dpValue: _dpValue,
+    updateDp: dpData => {
+      updateDp(cycleParser.formatter(dpData));
+    }
+  };
+}

package/lib/hooks/useCycleSupport.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description: 判断是否支持循环定时
+ * @param dpCodeList:  dpCode 列表 string[]
+ * @return {
+ *     isReady: boolean,
+ *     isSupport: boolean
+ * }
+ */
+export declare const useCycleSupport: (dpCodeList?: string[]) => {
+    isReady: boolean;
+    isSupport: boolean;
+};

package/lib/hooks/useCycleSupport.js

@@ -0,0 +1,16 @@
+import { scheduleDpCodes } from '../config/dpCodes';
+import { useCommonSupport } from './useCommonSupport';
+
+/**
+ * @description: 判断是否支持循环定时
+ * @param dpCodeList:  dpCode 列表 string[]
+ * @return {
+ *     isReady: boolean,
+ *     isSupport: boolean
+ * }
+ */
+export const useCycleSupport = function () {
+  let dpCodeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  const support = useCommonSupport([scheduleDpCodes.CYCLE_TIMING], dpCodeList);
+  return support;
+};

package/lib/hooks/useRandomDp.d.ts

@@ -0,0 +1,7 @@
+import { TRandomData } from '../types';
+type TDpRes = {
+    dpValue: TRandomData;
+    updateDp: (value: TRandomData) => void;
+};
+export declare function useRandomDp(dpCode?: "random_timing"): TDpRes;
+export {};

package/lib/hooks/useRandomDp.js

@@ -0,0 +1,21 @@
+import { useMemo } from 'react';
+import { useBaseLightDp } from './useBaseLightDp';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { getRandomParser } from '../dpParser/random';
+export function useRandomDp() {
+  let dpCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.RANDOM_TIMING;
+  const {
+    dpValue,
+    updateDp
+  } = useBaseLightDp(dpCode);
+  const randomParser = getRandomParser();
+  const _dpValue = useMemo(() => {
+    return randomParser.parser(dpValue);
+  }, [dpValue]);
+  return {
+    dpValue: _dpValue,
+    updateDp: dpData => {
+      updateDp(randomParser.formatter(dpData));
+    }
+  };
+}

package/lib/hooks/useRandomSupport.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description: 判断是否支持随机定时（灯光看家）
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {
+ *     isReady: boolean,
+ *     isSupport: boolean
+ * }
+ */
+export declare const useRandomSupport: (dpCodeList?: string[]) => {
+    isReady: boolean;
+    isSupport: boolean;
+};

package/lib/hooks/useRandomSupport.js

@@ -0,0 +1,16 @@
+import { scheduleDpCodes } from '../config/dpCodes';
+import { useCommonSupport } from './useCommonSupport';
+
+/**
+ * @description: 判断是否支持随机定时（灯光看家）
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {
+ *     isReady: boolean,
+ *     isSupport: boolean
+ * }
+ */
+export const useRandomSupport = function () {
+  let dpCodeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  const support = useCommonSupport([scheduleDpCodes.RANDOM_TIMING], dpCodeList);
+  return support;
+};

package/lib/hooks/useRhythmsDp.d.ts

@@ -0,0 +1,7 @@
+import { TRhythmData } from '../types';
+type TDpRes = {
+    dpValue: TRhythmData | null;
+    updateDp: (value: TRhythmData) => void;
+};
+export declare function useRhythmsDp(dpCode?: "rhythm_mode"): TDpRes;
+export {};

package/lib/hooks/useRhythmsDp.js

@@ -0,0 +1,23 @@
+import { useMemo } from 'react';
+import { useBaseLightDp } from './useBaseLightDp';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { rhythmParser } from '../dpParser/rhythms';
+export function useRhythmsDp() {
+  let dpCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.RHYTHM_MODE;
+  const {
+    dpValue,
+    updateDp
+  } = useBaseLightDp(dpCode);
+  const _dpValue = useMemo(() => {
+    if (typeof dpValue === 'string') {
+      return rhythmParser.parser(dpValue);
+    }
+    return dpValue;
+  }, [dpValue]);
+  return {
+    dpValue: _dpValue,
+    updateDp: dpData => {
+      updateDp(rhythmParser.formatter(dpData));
+    }
+  };
+}

package/lib/hooks/useSleepDp.d.ts

@@ -0,0 +1,6 @@
+type TDpRes<T> = {
+    dpValue: T;
+    updateDp: (value: T) => void;
+};
+export declare function useSleepDp<T>(dpCode?: string): TDpRes<T>;
+export {};

package/lib/hooks/useSleepDp.js

@@ -0,0 +1,21 @@
+import { useMemo } from 'react';
+import { useBaseLightDp } from './useBaseLightDp';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { getSleepParser } from '../dpParser/sleep';
+export function useSleepDp() {
+  let dpCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.SLEEP_MODE;
+  const {
+    dpValue,
+    updateDp
+  } = useBaseLightDp(dpCode);
+  const sleepParser = getSleepParser();
+  const _dpValue = useMemo(() => {
+    return sleepParser.parser(dpValue);
+  }, [dpValue]);
+  return {
+    dpValue: _dpValue,
+    updateDp: dpData => {
+      updateDp(sleepParser.formatter(dpData));
+    }
+  };
+}

package/lib/hooks/useSleepSupport.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @description: 判断是否入睡功能
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {isReady: boolean, isSupport: boolean}
+ */
+export declare const useSleepSupport: (dpCodeList?: string[]) => {
+    isSupport: boolean;
+};

package/lib/hooks/useSleepSupport.js

@@ -0,0 +1,13 @@
+import { scheduleDpCodes } from '../config/dpCodes';
+import { useCommonSupport } from './useCommonSupport';
+
+/**
+ * @description: 判断是否入睡功能
+ * @param dpCodeList: 倒计时 dpCode 列表 string[]
+ * @return {isReady: boolean, isSupport: boolean}
+ */
+export const useSleepSupport = function () {
+  let dpCodeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  const support = useCommonSupport([scheduleDpCodes.SLEEP_MODE], dpCodeList);
+  return support;
+};

package/lib/hooks/useTimeFlush.d.ts

@@ -0,0 +1,8 @@
+import { IContext } from '../context/timer/type';
+import { TTimerData } from '../types';
+export declare const useTimerContext: () => IContext;
+export { useCloudTimerListFlush } from '../hooks/useTimerFlushList';
+export declare const useTimerListFlush: () => {
+    isReady: boolean;
+    flushTimerList: (data: TTimerData[]) => void;
+};

package/lib/hooks/useTimeFlush.js

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import { useContext, useCallback } from 'react';
+import { TimerContext } from '../context/timer/context';
+import { useSupportLocalTimer } from './useTimerSupport';
+export const useTimerContext = () => {
+  return useContext(TimerContext);
+};
+export { useCloudTimerListFlush } from '../hooks/useTimerFlushList';
+
+// 获取定时刷新， 内部判断云定时或本地定时
+export const useTimerListFlush = () => {
+  const {
+    isSupport,
+    isReady
+  } = useSupportLocalTimer();
+  const {
+    actions,
+    dispatch
+  } = useTimerContext();
+  const flushTimerList = useCallback(data => {
+    if (isSupport) {
+      dispatch(actions.flushRtcTimerList(data));
+    } else {
+      dispatch(actions.flushCloudTimerList(data));
+    }
+  }, [actions, dispatch, isSupport, isReady]);
+  return {
+    isReady,
+    flushTimerList
+  };
+};

package/lib/hooks/useTimerDp.d.ts

@@ -0,0 +1,5 @@
+import { TRtcTimer } from '../types';
+export declare function useTimerDp(dpCode?: "rtc_timer"): {
+    dpValue: TRtcTimer;
+    updateDp: (dps: TRtcTimer) => void;
+};

package/lib/hooks/useTimerDp.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-param-reassign */
+import { useMemo } from 'react';
+import { useBaseLightDp } from './useBaseLightDp';
+import { scheduleDpCodes } from '../config/dpCodes';
+import { rtcTimerParser } from '../dpParser/rtcTimer';
+// 本地定时dp下发
+export function useTimerDp() {
+  let dpCode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scheduleDpCodes.RTC_TIMER;
+  const {
+    dpValue,
+    updateDp
+  } = useBaseLightDp(dpCode);
+  const _dpValue = useMemo(() => {
+    if (typeof dpValue === 'string') {
+      return rtcTimerParser.parser(dpValue);
+    }
+    return dpValue;
+  }, [dpValue, rtcTimerParser]);
+  return {
+    dpValue: _dpValue,
+    updateDp: rtcTimerDp => {
+      updateDp(rtcTimerParser.formatter(rtcTimerDp));
+    }
+  };
+}

package/lib/hooks/useTimerFlushList.d.ts

@@ -0,0 +1,11 @@
+import { TTimerData, TTimerDataUpdate } from '../types';
+export declare const useCloudTimerListFlush: () => {
+    flushCloudTimerList: (data: TTimerDataUpdate[]) => void;
+};
+export declare const useRtcTimerListFlush: () => {
+    flushRtcTimerList: (data: TTimerData[]) => void;
+};
+export declare const useTimerListFlush: () => {
+    isReady: boolean;
+    flushTimerList: (data: TTimerData[]) => void;
+};

package/lib/hooks/useTimerFlushList.js

@@ -0,0 +1,53 @@
+import { useCallback } from 'react';
+import { useTimerContext } from '../context/timer/context';
+import { useSupportLocalTimer } from './useTimerSupport';
+// 获取云定时刷新
+export const useCloudTimerListFlush = () => {
+  const {
+    actions,
+    dispatch
+  } = useTimerContext();
+  const flushCloudTimerList = useCallback(data => {
+    dispatch(actions.flushCloudTimerList(data));
+  }, [actions, dispatch]);
+  return {
+    flushCloudTimerList
+  };
+};
+
+// 获取本地定时刷新
+export const useRtcTimerListFlush = () => {
+  const {
+    actions,
+    dispatch
+  } = useTimerContext();
+  const flushRtcTimerList = useCallback(data => {
+    dispatch(actions.flushRtcTimerList(data));
+  }, [actions, dispatch]);
+  return {
+    flushRtcTimerList
+  };
+};
+
+// 获取定时刷新， 内部判断云定时或本地定时
+export const useTimerListFlush = () => {
+  const {
+    isSupport,
+    isReady
+  } = useSupportLocalTimer();
+  const {
+    actions,
+    dispatch
+  } = useTimerContext();
+  const flushTimerList = useCallback(data => {
+    if (isSupport) {
+      dispatch(actions.flushRtcTimerList(data));
+    } else {
+      dispatch(actions.flushCloudTimerList(data));
+    }
+  }, [actions, dispatch, isSupport, isReady]);
+  return {
+    isReady,
+    flushTimerList
+  };
+};