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

package/lib/conflict/index.js

@@ -0,0 +1,103 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.find.js";
+import { scheduleLogger } from '../utils/ScheduleLogger';
+import { checkConflicts } from './ConflictResolver';
+import { ScheduleDataManager } from './scheduleDataManager';
+import { transScheduleListToConflictList } from './transform';
+
+/**
+ * 冲突检测
+ */
+export class Conflict {
+  /**
+   * 添加冲突规则
+   */
+  static addConflictRule(rule) {
+    Conflict.rule = rule;
+    scheduleLogger.debug('Conflict.addConflictRule:', rule);
+  }
+
+  /**
+   * 添加新日程时检测冲突
+   *
+   * @param current - 待添加的日程对象，类型为 Schedule
+   * @returns 返回冲突检测结果对象，包含:
+   *          isConflict - 是否存在冲突的布尔值
+   *          conflictList - 具体的冲突检测结果数组
+   */
+  static add(current) {
+    const instance = ScheduleDataManager.getInstance();
+    const preList = instance.getData() || [];
+    const [cur] = transScheduleListToConflictList([current]);
+    scheduleLogger.debug('Conflict.add cur, current:', cur, current);
+    const conflictList = checkConflicts(preList, cur, Conflict.rule);
+    const isConflict = conflictList.length > 0;
+    // 如果存在冲突，不保存数据
+    !isConflict && instance.setData(cur);
+    return {
+      isConflict,
+      conflictList
+    };
+  }
+
+  /**
+   * 删除日程
+   *
+   * @param current - 待添加的日程对象，类型为 Schedule
+   * @returns void
+   */
+  static remove(current) {
+    const [cur] = transScheduleListToConflictList([current]);
+    scheduleLogger.debug('Conflict.remove cur, current:', cur, current);
+    cur && ScheduleDataManager.getInstance().deleteData(cur);
+  }
+
+  /**
+   * 更新新日程时检测冲突
+   *
+   * @param current - 待更新的日程对象，类型为 Schedule
+   * @returns 返回冲突检测结果对象，包含:
+   *          isConflict - 是否存在冲突的布尔值
+   *          conflictList - 具体的冲突检测结果数组
+   */
+  static update(current, prevSchedule) {
+    scheduleLogger.debug('Conflict.update:', current, prevSchedule);
+    if (!prevSchedule) {
+      scheduleLogger.error('Conflict.update: prevSchedule is empty: current', current);
+    }
+    const instance = ScheduleDataManager.getInstance();
+    const [cur, prev] = transScheduleListToConflictList([current, prevSchedule]);
+    scheduleLogger.debug('Conflict.update1:', cur, prev);
+    const preList = instance.getData() || [];
+    const _current = _objectSpread(_objectSpread({}, cur), {}, {
+      prevId: prev.id
+    });
+    const conflictList = checkConflicts(preList, _current, Conflict.rule);
+    const isConflict = conflictList.length > 0;
+    if (!isConflict && prev) {
+      //  如果没有冲突说明可以更新，需要删除之前的项，防止之前项目一致存在影响正常判断冲突
+      const preItem = preList.find(i => i.id === prev.id);
+      preItem && instance.deleteData(preItem);
+      instance.setData(_current);
+    }
+    return {
+      isConflict,
+      conflictList
+    };
+  }
+
+  /**
+   * 当进入面板后，初始化需要冲突判断的计划数据，便于后续增删改冲突判断
+   * @param scheduleList - 需要冲突判断的计划数据
+   */
+  static init(scheduleList) {
+    if (!Array.isArray(scheduleList)) {
+      return;
+    }
+    const instance = ScheduleDataManager.getInstance();
+    const _scheduleList = transScheduleListToConflictList(scheduleList);
+    scheduleLogger.debug('Conflict.init scheduleList, _scheduleList:', scheduleList, _scheduleList);
+    instance.setData(_scheduleList);
+  }
+}

package/lib/conflict/scheduleDataManager.d.ts

@@ -0,0 +1,12 @@
+import { Schedule } from './type';
+export declare class ScheduleDataManager {
+    static instance: ScheduleDataManager;
+    static list: Record<string, any>[];
+    static getInstance(): ScheduleDataManager;
+    getData(): Record<string, any>[];
+    setData(value: Record<string, any>[] | Record<string, any>): void;
+    clearData(): void;
+    deleteData(current: Schedule): void;
+    remove(id: string): void;
+}
+export default ScheduleDataManager;

package/lib/conflict/scheduleDataManager.js

@@ -0,0 +1,79 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+// 统一管理 计划 数据列表，用来判断是否存在冲突
+export class ScheduleDataManager {
+  static list = [];
+  static getInstance() {
+    if (!ScheduleDataManager.instance) {
+      ScheduleDataManager.instance = new ScheduleDataManager();
+    }
+    return ScheduleDataManager.instance;
+  }
+  getData() {
+    return ScheduleDataManager.list;
+  }
+  setData(value) {
+    if (!value) {
+      return;
+    }
+
+    // 创建一个新的列表，而不是修改现有列表
+    let newList = [...ScheduleDataManager.list];
+    if (Array.isArray(value)) {
+      value.forEach(item => {
+        if (Array.isArray(item)) {
+          item.forEach(_item => {
+            if (!_item || !_item.id) {
+              return;
+            }
+            // 如果跟之前id相同需要先删除
+            newList = newList.filter(i => i.id !== _item.id);
+            // 添加新项
+            newList.push(_item);
+          });
+        } else {
+          if (!item || !item.id) {
+            return;
+          }
+          // 如果跟之前id相同需要先删除
+          newList = newList.filter(i => i.id !== item.id);
+          // 添加新项
+          newList.push(item);
+        }
+      });
+    } else {
+      if (!value || !value.id) {
+        return;
+      }
+      // 如果跟之前id相同需要先删除
+      newList = newList.filter(i => i.id !== value.id);
+      // 添加新项
+      newList.push(value);
+    }
+
+    // 更新列表
+    ScheduleDataManager.list = newList;
+  }
+  clearData() {
+    ScheduleDataManager.list = [];
+  }
+  deleteData(current) {
+    if (!current) {
+      return;
+    }
+    const index = ScheduleDataManager.list.findIndex(item => item.id === current.id);
+    if (index !== -1) {
+      ScheduleDataManager.list.splice(index, 1);
+    }
+  }
+
+  // 添加remove方法作为deleteData的别名，用于测试
+  remove(id) {
+    const index = ScheduleDataManager.list.findIndex(item => item.id === id);
+    if (index !== -1) {
+      ScheduleDataManager.list.splice(index, 1);
+    }
+  }
+}
+export default ScheduleDataManager;

package/lib/conflict/transform.d.ts

@@ -0,0 +1,71 @@
+import { TWakeUpNode, TSleepNode, TRandomNode, TRhythmData, TCountdownSchedule, TTimerDataUpdate, TCycleNode } from '../types';
+import { Schedule, TFoldScheduleList } from './type';
+/**
+ * TTimerDataAdd => Schedule
+ * 定时数据转换成适合冲突判断的日程对象
+ * @param data TTimerDataAdd
+ * @returns Schedule
+ */
+export declare const timerDataToSchedule: <T extends TTimerDataUpdate>(data: T) => Schedule;
+/**
+ * @description: 定时转换为适合冲突判断的日程列表
+ * @param {TTimerDataAdd} data
+ * @return Schedule[]
+ */
+export declare const timerListToScheduleList: <T extends TTimerDataUpdate>(data: T[]) => Schedule[];
+/**
+ * TWakeUpData => Schedule
+ * 唤醒数据转换成适合冲突判断的日程对象
+ * @param data TWakeUpData
+ * @returns Schedule
+ */
+export declare const wakeUpNodeToSchedule: <T extends TWakeUpNode>(data: T) => Schedule;
+/**
+ * @description: 入睡定时转换为适合冲突判断的日程列表
+ * @param {TWakeUpNode[]} data
+ * @return Schedule[]
+ */
+export declare const wakeUpDataToScheduleList: <T extends TWakeUpNode>(data: T[]) => Schedule[];
+/**
+ * TSleepNode => Schedule
+ * 唤醒数据转换成适合冲突判断的日程对象
+ * @param data TSleepNode
+ * @returns Schedule
+ */
+export declare const sleepNodeToSchedule: <T extends TSleepNode>(data: T) => Schedule;
+/**
+ * @description: 入睡定时转换为适合冲突判断的日程列表
+ * @param {TSleepNode[]} data
+ * @return Schedule[]
+ */
+export declare const sleepDataToScheduleList: <T extends TSleepNode>(data: T[]) => Schedule[];
+/**
+ * @description: 倒计时定时转换为适合冲突判断的日程列表
+ */
+export declare const countdownToSchedule: <T extends TCountdownSchedule>(data: T) => Schedule;
+export declare const rhythmToSchedule: <T extends TRhythmData>(rhythm: T) => Schedule;
+/**
+ * @description 将随机定时数据转换为适合冲突判断的日程对象
+ * @param data TRandomNode
+ * @returns Schedule
+ */
+export declare const randomNodeToSchedule: <T extends TRandomNode>(data: T) => Schedule;
+/**
+ * @description: 随机定时转换为适合冲突判断的日程列表
+ * @param {TRandomNode[]} data
+ * @return Schedule[]
+ */
+export declare const randomDataToScheduleList: <T extends TRandomNode>(data: T[]) => Schedule[];
+/**
+ * @description 将循环定时数据转换为适合冲突判断的日程对象
+ * @param data TCycleNode
+ * @returns Schedule
+ */
+export declare const cycleNodeToSchedule: <T extends TCycleNode>(data: T) => Schedule;
+/**
+ * @description: 循环定时转换为适合冲突判断的日程列表
+ * @param {TCycleNode[]} data
+ * @return Schedule[]
+ */
+export declare const cycleDataToScheduleList: <T extends TCycleNode>(data: T[]) => Schedule[];
+export declare const transScheduleListToConflictList: (foldScheduleList: TFoldScheduleList) => Schedule[];

package/lib/conflict/transform.js

@@ -0,0 +1,251 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.js";
+import dayjs from 'dayjs';
+import { getBackwardOffsetTimeByHourMins, getPreOffsetTimeByHourMins, getTimerStrByMinutes } from '../utils/time';
+import { EScheduleFunctionType } from '../types';
+import { scheduleLogger } from '../utils/ScheduleLogger';
+const numAddZero = num => {
+  return +num < 10 ? `0${+num}` : +num;
+};
+
+/**
+ * TTimerDataAdd => Schedule
+ * 定时数据转换成适合冲突判断的日程对象
+ * @param data TTimerDataAdd
+ * @returns Schedule
+ */
+export const timerDataToSchedule = data => {
+  var _data$status;
+  scheduleLogger.debug('timerDataToSchedule:', data);
+  return {
+    id: `${EScheduleFunctionType.TIMER}_${data.time}_${data.loops}`,
+    type: EScheduleFunctionType.TIMER,
+    data: {
+      status: (_data$status = data.status) !== null && _data$status !== void 0 ? _data$status : false,
+      weeks: data.loops.split('').map(item => Number(item)),
+      startTime: data.time,
+      endTime: data.time
+    }
+  };
+};
+
+/**
+ * @description: 定时转换为适合冲突判断的日程列表
+ * @param {TTimerDataAdd} data
+ * @return Schedule[]
+ */
+export const timerListToScheduleList = data => {
+  return data.map(node => {
+    return timerDataToSchedule(node);
+  });
+};
+
+/**
+ * TWakeUpData => Schedule
+ * 唤醒数据转换成适合冲突判断的日程对象
+ * @param data TWakeUpData
+ * @returns Schedule
+ */
+export const wakeUpNodeToSchedule = data => {
+  const startTime = getPreOffsetTimeByHourMins(data.hour, data.minute, data.step * 5 || 0);
+  const endTime = getBackwardOffsetTimeByHourMins(data.hour, data.minute, data.duration * 5);
+  scheduleLogger.debug('wakeUpNodeToSchedule:', data);
+  return {
+    id: `${EScheduleFunctionType.WAKEUP}_${numAddZero(data.hour)}_${numAddZero(data.minute)}_${data.loops}`,
+    type: EScheduleFunctionType.WAKEUP,
+    data: {
+      status: data.onOff,
+      weeks: data.loops.split('').map(item => Number(item)),
+      startTime,
+      endTime
+    }
+  };
+};
+
+/**
+ * @description: 入睡定时转换为适合冲突判断的日程列表
+ * @param {TWakeUpNode[]} data
+ * @return Schedule[]
+ */
+export const wakeUpDataToScheduleList = data => {
+  return data.map(node => {
+    return wakeUpNodeToSchedule(node);
+  });
+};
+
+/**
+ * TSleepNode => Schedule
+ * 唤醒数据转换成适合冲突判断的日程对象
+ * @param data TSleepNode
+ * @returns Schedule
+ */
+export const sleepNodeToSchedule = data => {
+  const startTime = getPreOffsetTimeByHourMins(data.hour, data.minute, data.step * 5);
+  scheduleLogger.debug('sleepNodeToSchedule:', data);
+  return {
+    id: `${EScheduleFunctionType.SLEEP}_${numAddZero(data.hour)}_${numAddZero(data.minute)}_${data.loops}`,
+    type: EScheduleFunctionType.SLEEP,
+    data: {
+      status: data.onOff,
+      weeks: data.loops.split('').map(item => Number(item)),
+      startTime,
+      endTime: data.time
+    }
+  };
+};
+
+/**
+ * @description: 入睡定时转换为适合冲突判断的日程列表
+ * @param {TSleepNode[]} data
+ * @return Schedule[]
+ */
+export const sleepDataToScheduleList = data => {
+  return data.map(node => {
+    return sleepNodeToSchedule(node);
+  });
+};
+
+/**
+ * @description: 倒计时定时转换为适合冲突判断的日程列表
+ */
+export const countdownToSchedule = data => {
+  scheduleLogger.debug('countdownToSchedule:', data);
+  const {
+    countdown
+  } = data;
+  const now = dayjs().format('HH:mm');
+  const [hour, minute] = now === null || now === void 0 ? void 0 : now.split(':');
+  const endTime = getBackwardOffsetTimeByHourMins(+hour, +minute, Math.floor(countdown / 60));
+  return {
+    id: `${EScheduleFunctionType.COUNTDOWN}`,
+    type: EScheduleFunctionType.COUNTDOWN,
+    data: {
+      status: !!countdown,
+      weeks: [0, 0, 0, 0, 0, 0, 0],
+      startTime: now,
+      endTime
+    }
+  };
+};
+export const rhythmToSchedule = rhythm => {
+  scheduleLogger.debug('rhythmToSchedule:', rhythm);
+  return {
+    id: `${EScheduleFunctionType.RHYTHM}`,
+    type: EScheduleFunctionType.RHYTHM,
+    data: {
+      status: rhythm.power,
+      weeks: rhythm.weeks,
+      startTime: '00:00',
+      endTime: '23:59'
+    }
+  };
+};
+
+/**
+ * @description 将随机定时数据转换为适合冲突判断的日程对象
+ * @param data TRandomNode
+ * @returns Schedule
+ */
+export const randomNodeToSchedule = data => {
+  scheduleLogger.debug('randomNodeToSchedule:', data);
+  const {
+    startTime,
+    endTime
+  } = data;
+  const startTimeStr = getTimerStrByMinutes(startTime);
+  const endTimeStr = getTimerStrByMinutes(endTime);
+  return {
+    id: `${EScheduleFunctionType.RANDOM}_${data.startTime}_${data.endTime}_${data.loops}`,
+    type: EScheduleFunctionType.RANDOM,
+    data: {
+      status: data.onOff,
+      weeks: data.loops.split('').map(item => Number(item)),
+      startTime: startTimeStr,
+      endTime: endTimeStr
+    }
+  };
+};
+
+/**
+ * @description: 随机定时转换为适合冲突判断的日程列表
+ * @param {TRandomNode[]} data
+ * @return Schedule[]
+ */
+export const randomDataToScheduleList = data => {
+  return data.map(node => {
+    return randomNodeToSchedule(node);
+  });
+};
+
+/**
+ * @description 将循环定时数据转换为适合冲突判断的日程对象
+ * @param data TCycleNode
+ * @returns Schedule
+ */
+export const cycleNodeToSchedule = data => {
+  scheduleLogger.debug('randomNodeToSchedule:', data);
+  const {
+    startTime,
+    endTime
+  } = data;
+  const startTimeStr = getTimerStrByMinutes(startTime);
+  const endTimeStr = getTimerStrByMinutes(endTime);
+  return {
+    id: `${EScheduleFunctionType.CYCLE}_${data.startTime}_${data.endTime}_${data.loops}`,
+    type: EScheduleFunctionType.CYCLE,
+    data: {
+      status: data.onOff,
+      weeks: data.loops.split('').map(item => Number(item)),
+      startTime: startTimeStr,
+      endTime: endTimeStr
+    }
+  };
+};
+
+/**
+ * @description: 循环定时转换为适合冲突判断的日程列表
+ * @param {TCycleNode[]} data
+ * @return Schedule[]
+ */
+export const cycleDataToScheduleList = data => {
+  return data.map(node => {
+    return cycleNodeToSchedule(node);
+  });
+};
+export const transScheduleListToConflictList = foldScheduleList => {
+  let arr = [];
+  try {
+    foldScheduleList.forEach(item => {
+      if (item.type === EScheduleFunctionType.RANDOM) {
+        const list = randomDataToScheduleList(Array.isArray(item.detail) ? item.detail : [item.detail]);
+        arr = arr.concat(list);
+      } else if (item.type === EScheduleFunctionType.CYCLE) {
+        const list = cycleDataToScheduleList(Array.isArray(item.detail) ? item.detail : [item.detail]);
+        arr = arr.concat(list);
+      } else if (item.type === EScheduleFunctionType.TIMER) {
+        const list = timerListToScheduleList(Array.isArray(item.detail) ? item.detail : [item.detail]);
+        arr = arr.concat(list);
+      } else if (item.type === EScheduleFunctionType.WAKEUP) {
+        const list = wakeUpDataToScheduleList(Array.isArray(item.detail) ? item.detail : [item.detail]);
+        arr = arr.concat(list);
+      } else if (item.type === EScheduleFunctionType.SLEEP) {
+        const list = sleepDataToScheduleList(Array.isArray(item.detail) ? item.detail : [item.detail]);
+        arr = arr.concat(list);
+      } else if (item.type === EScheduleFunctionType.RHYTHM) {
+        var _item$detail;
+        const list = rhythmToSchedule(Array.isArray(item.detail) ? item === null || item === void 0 || (_item$detail = item.detail) === null || _item$detail === void 0 ? void 0 : _item$detail[0] : item.detail);
+        arr = arr.concat(list);
+      } else if (item.type === EScheduleFunctionType.COUNTDOWN) {
+        var _item$detail2;
+        const list = countdownToSchedule(Array.isArray(item.detail) ? item === null || item === void 0 || (_item$detail2 = item.detail) === null || _item$detail2 === void 0 ? void 0 : _item$detail2[0] : item.detail);
+        arr = arr.concat(list);
+      } else {
+        scheduleLogger.error('getScheduleListByType', item, '未匹配到类型');
+      }
+    });
+  } catch (error) {
+    scheduleLogger.error('transScheduleListToConflictList', error);
+  }
+  return arr;
+};

package/lib/conflict/type.d.ts

@@ -0,0 +1,55 @@
+import { EScheduleFunctionType, TRandomNode, TTimerDataUpdate, TWakeUpNode, TSleepNode, TRhythmData, TCountdownSchedule } from '../types';
+export interface Schedule {
+    id: string;
+    prevId?: string;
+    type: EScheduleFunctionType;
+    data: {
+        status: boolean;
+        weeks: number[];
+        time?: string;
+        startTime?: string;
+        endTime?: string;
+    };
+}
+export declare enum DayOfWeek {
+    Sunday = "Sunday",
+    Monday = "Monday",
+    Tuesday = "Tuesday",
+    Wednesday = "Wednesday",
+    Thursday = "Thursday",
+    Friday = "Friday",
+    Saturday = "Saturday",
+    Single = "single"
+}
+export type TConflictRes = {
+    isConflict: boolean;
+    conflictList: {
+        current: Schedule;
+        other: Schedule;
+    }[];
+};
+export interface ConflictResult {
+    current: Schedule;
+    other: Schedule;
+}
+export interface UnifiedTimeRange {
+    id: string;
+    type: EScheduleFunctionType;
+    dayOfWeek: DayOfWeek;
+    startMinutes: number;
+    endMinutes: number;
+    originalSchedule: Schedule;
+    isCrossDay: boolean;
+}
+export interface ConflictRule {
+    isConflict(a: UnifiedTimeRange, b: UnifiedTimeRange): boolean;
+    shouldIgnore?(a: UnifiedTimeRange, b: UnifiedTimeRange): boolean;
+}
+type ScheduleNodeType = TRandomNode | TTimerDataUpdate | TWakeUpNode | TSleepNode | TRhythmData | TCountdownSchedule;
+export type TSchedule = {
+    id?: string;
+    type: EScheduleFunctionType;
+    detail: ScheduleNodeType[];
+};
+export type TFoldScheduleList = TSchedule[];
+export {};

package/lib/conflict/type.js

@@ -0,0 +1,17 @@
+export let DayOfWeek = /*#__PURE__*/function (DayOfWeek) {
+  DayOfWeek["Sunday"] = "Sunday";
+  DayOfWeek["Monday"] = "Monday";
+  DayOfWeek["Tuesday"] = "Tuesday";
+  DayOfWeek["Wednesday"] = "Wednesday";
+  DayOfWeek["Thursday"] = "Thursday";
+  DayOfWeek["Friday"] = "Friday";
+  DayOfWeek["Saturday"] = "Saturday";
+  DayOfWeek["Single"] = "single";
+  return DayOfWeek;
+}({});
+
+// 冲突结果接口
+
+// 统一时间范围类型
+
+// 规则接口

package/lib/conflict/updateDeviceDp.d.ts

@@ -0,0 +1 @@
+export declare const updateDeviceDp: (devId: string, groupId: string, dps: Record<string, {}>) => void;

package/lib/conflict/updateDeviceDp.js

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/ban-types */
+import { publishDps, publishGroupDpCodes } from '@ray-js/ray';
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+export const updateDeviceDp = (devId, groupId, dps) => {
+  if (Object.keys(dps).length === 0) {
+    ScheduleLogger.warn('updateDeviceDp', 'dps is empty');
+    return;
+  }
+  if (!devId && !groupId) {
+    ScheduleLogger.warn('updateDeviceDp', 'devId or groupId is empty');
+    return;
+  }
+  if (groupId) {
+    publishGroupDpCodes({
+      groupId,
+      dpCodes: dps,
+      success: () => {
+        ScheduleLogger.debug('publishGroupDpCodes dp success');
+      },
+      fail: err => {
+        ScheduleLogger.error('publishGroupDpCodes dp fail', err);
+      }
+    });
+    return;
+  }
+  ScheduleLogger.debug('updateDeviceDp publishDps dps:', dps);
+  publishDps({
+    deviceId: devId,
+    dps,
+    mode: 2,
+    pipelines: [0, 1, 2, 3, 4, 5, 6],
+    options: {},
+    success: () => {
+      ScheduleLogger.debug('publishDps dp success', dps);
+    },
+    fail: err => {
+      ScheduleLogger.error('publishDps dp fail', err);
+    }
+  });
+};

package/lib/constant/index.d.ts

@@ -0,0 +1,5 @@
+export declare const LOG_PREFIX = "[lamp-schedule-core] => ";
+export declare const COMPONENT_NAME = "lamp-schedule";
+export declare const LOCAL_TIMER_CATEGORY = "TimerKey";
+export declare const CLOUD_TIMER_CATEGORY = "timer";
+export declare const DP_CHANGE_EVENT_KEY = "dpChange";

package/lib/constant/index.js

@@ -0,0 +1,5 @@
+export const LOG_PREFIX = '[lamp-schedule-core] => ';
+export const COMPONENT_NAME = 'lamp-schedule';
+export const LOCAL_TIMER_CATEGORY = 'TimerKey';
+export const CLOUD_TIMER_CATEGORY = 'timer';
+export const DP_CHANGE_EVENT_KEY = 'dpChange';

package/lib/context/index.d.ts

@@ -0,0 +1,3 @@
+export { useRhythmContext, ContextProvider as RhythmsContextProvider, getRhythmsState, } from './rhythms';
+export { useTimerContext, ContextProviderTimer as TimerContextProvider, getTimerState, } from './timer';
+export { useScheduleContext, ContextProviderSchedule as ScheduleContextProvider, getScheduleState, } from './schedule';

package/lib/context/index.js

@@ -0,0 +1,3 @@
+export { useRhythmContext, ContextProvider as RhythmsContextProvider, getRhythmsState } from './rhythms';
+export { useTimerContext, ContextProviderTimer as TimerContextProvider, getTimerState } from './timer';
+export { useScheduleContext, ContextProviderSchedule as ScheduleContextProvider, getScheduleState } from './schedule';

package/lib/context/rhythms/actions.d.ts

@@ -0,0 +1,20 @@
+import { ERhythm } from '../../types/rhythms';
+interface IReturn {
+    type: ERhythm;
+    payload: any;
+}
+export declare const updateRhythmsMessage: (data: Record<string, any>) => IReturn;
+export declare const updateRhythms: (data: Record<string, any>) => IReturn;
+export declare const updateLocalMessage: (data: Record<string, any>) => IReturn;
+export declare const updateUI: (data: Record<string, any>) => IReturn;
+export declare const initSystemInfo: (data: Record<string, any>) => IReturn;
+export declare const updateDp: (data: Record<string, any>) => IReturn;
+declare const _default: {
+    updateLocalMessage: (data: Record<string, any>) => IReturn;
+    updateRhythms: (data: Record<string, any>) => IReturn;
+    updateRhythmsMessage: (data: Record<string, any>) => IReturn;
+    updateUI: (data: Record<string, any>) => IReturn;
+    initSystemInfo: (data: Record<string, any>) => IReturn;
+    updateDp: (data: Record<string, any>) => IReturn;
+};
+export default _default;