@ray-js/robot-data-stream 0.0.13-beta-7 → 0.0.13-beta-8

package/lib/mqtt/useQuiteHours.d.ts

@@ -1,6 +1,9 @@
-import { BaseResponse, QuietHoursEnum } from './type';
-interface QuietHoursResponse extends BaseResponse {
-    reqType: QuietHoursEnum.query;
+type Response = {
+    reqType: string;
+    /**
+     * 版本号
+     */
+    version: string;
     /**
      * 是否激活
      * 0 表示未激活，1 表示激活
@@ -14,8 +17,20 @@ interface QuietHoursResponse extends BaseResponse {
      * 星期几，1 表示星期一，2 表示星期二，以此类推
      */
     day: number;
-}
-interface SetQuiteHoursParams {
+    /**
+     * 请求是否成功
+     */
+    success: boolean;
+    /**
+     * 错误代码，0 表示无错误
+     */
+    errCode: number;
+    /**
+     * 任务ID
+     */
+    taskId: string;
+};
+type TSetQuiteHours = (params: {
     startTime: {
         hour: number;
         minute: number;
@@ -27,9 +42,9 @@ interface SetQuiteHoursParams {
     active: number;
     day: number;
     version?: string;
-}
-type TSetQuiteHours = (params: SetQuiteHoursParams) => Promise<QuietHoursResponse>;
-type TRequestQuiteHours = () => Promise<QuietHoursResponse>;
+}) => Promise<Response> | Promise<{
+    success: boolean;
+}>;
 /**
  * 自定义 Hook，用于勿扰模式
  * @param devId 设备ID
@@ -37,6 +52,6 @@ type TRequestQuiteHours = () => Promise<QuietHoursResponse>;
  */
 export declare const useQuiteHours: (devId: string) => {
     setQuiteHours: TSetQuiteHours;
-    requestQuiteHours: TRequestQuiteHours;
+    requestQuiteHours: () => Promise<Response>;
 };
 export {};

package/lib/mqtt/useQuiteHours.js

@@ -1,3 +1,6 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+const _excluded = ["startTime", "endTime"];
 // 勿扰模式
 import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
@@ -6,14 +9,8 @@ import { QuietHoursEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeDoNotDisturb0x32 } from '@ray-js/robot-protocol';
 
-// 勿扰模式响应类型
-
-// 设置勿扰模式参数类型
-
 // 设置勿扰模式函数类型定义
 
-// 请求勿扰模式函数类型定义
-
 /**
  * 自定义 Hook，用于勿扰模式
  * @param devId 设备ID
@@ -27,109 +24,69 @@ export const useQuiteHours = devId => {
   } = useContext(SingletonContext);
   /**
    * 请求勿扰模式数据
-   * @returns Promise<QuietHoursResponse> 响应结果
+   * @returns Promise<{ time: string[]; day: number; active: number }> 响应结果
    */
 
   /**
    * 设置勿扰模式
-   * @param params 包含勿扰模式设置参数的对象
-   * @returns Promise<QuietHoursResponse> 响应结果
+   * @param message 包含勿扰模式设置参数的对象
+   * @returns Promise<Response> 响应结果
    */
 
   return {
-    setQuiteHours: params => {
+    setQuiteHours: message => {
       const {
-        startTime,
-        endTime,
-        active,
-        day
-      } = params;
-
-      // 参数验证
-      if (!startTime || typeof startTime.hour !== 'number' || typeof startTime.minute !== 'number') {
-        throw new Error('startTime is required and must be an object with hour and minute properties');
-      }
-      if (!endTime || typeof endTime.hour !== 'number' || typeof endTime.minute !== 'number') {
-        throw new Error('endTime is required and must be an object with hour and minute properties');
-      }
-      if (typeof active !== 'number' || active !== 0 && active !== 1) {
-        throw new Error('active is required and must be 0 or 1');
-      }
-      if (typeof day !== 'number') {
-        throw new Error('day is required and must be a number');
-      }
-      const {
-        hour: h0,
-        minute: m0
-      } = startTime;
-      const {
-        hour: h1,
-        minute: m1
-      } = endTime;
-      if (h0 < 0 || h0 > 23 || m0 < 0 || m0 > 59) {
-        throw new Error('startTime is invalid: hour must be 0-23, minute must be 0-59');
-      }
-      if (h1 < 0 || h1 > 23 || m1 < 0 || m1 > 59) {
-        throw new Error('endTime is invalid: hour must be 0-23, minute must be 0-59');
-      }
-      try {
-        if (useMqtt) {
-          const mqttParams = createSetCommonParams({
-            deviceId: devId,
-            reqType: QuietHoursEnum.set,
-            message: {
-              time: [`${h0},${m0}`, `${h1},${m1}`],
-              active,
-              day
-            }
-          });
-          ty.device.sendMqttMessage(mqttParams);
-          const {
-            taskId
-          } = mqttParams.message;
-          return normalResolve(QuietHoursEnum.query, taskId);
+          startTime,
+          endTime
+        } = message,
+        others = _objectWithoutProperties(message, _excluded);
+      if (useMqtt) {
+        if (!startTime || !endTime) {
+          throw new Error('Invalid time');
+        }
+        const {
+          hour: h0,
+          minute: m0
+        } = startTime;
+        const {
+          hour: h1,
+          minute: m1
+        } = endTime;
+        if (h0 > 23 || h0 < 0 || h1 > 23 || h1 < 0 || m0 > 59 || m0 < 0 || m1 > 59 || m1 < 0) {
+          throw new Error('Invalid time');
         }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodeDoNotDisturb0x32({
-          version: commandVersion,
-          startHour: h0,
-          startMinute: m0,
-          endHour: h1,
-          endMinute: m1
-        });
-        devices.common.model.actions.disturb_time_set.set(command);
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: QuietHoursEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          active,
-          time: [`${h0},${m0}`, `${h1},${m1}`],
-          day
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set quiet hours');
-      }
-    },
-    requestQuiteHours: () => {
-      if (!useMqtt) {
-        return Promise.reject(new Error('useMqtt is not used'));
-      }
-      try {
         const params = createSetCommonParams({
           deviceId: devId,
-          reqType: QuietHoursEnum.query
+          reqType: QuietHoursEnum.set,
+          message: _objectSpread({
+            time: [`${h0},${m0}`, `${h1},${m1}`]
+          }, others)
         });
         ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(QuietHoursEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request quiet hours'));
+        return normalResolve(QuietHoursEnum.query, params.message.taskId);
       }
+      const command = encodeDoNotDisturb0x32({
+        version: commandVersion,
+        startHour: startTime.hour,
+        startMinute: startTime.minute,
+        endHour: endTime.hour,
+        endMinute: endTime.minute
+      });
+      devices.common.model.actions.disturb_time_set.set(command);
+      return Promise.resolve({
+        success: true
+      });
+    },
+    requestQuiteHours: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: QuietHoursEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(QuietHoursEnum.query, taskId);
     }
   };
 };

package/lib/mqtt/useResetMap.d.ts

@@ -1,13 +1,10 @@
-import { BaseResponse, ResetCurrMapEnum } from './type';
-interface ResetMapResponse extends BaseResponse {
-    reqType: ResetCurrMapEnum.query;
-}
-type TSetResetMap = () => Promise<ResetMapResponse>;
-/**
- * 自定义 Hook，用于重置地图
- * @param devId 设备ID
- * @returns 包含 setResetMap 函数的对象
- */
+type TSetResetMap = () => Promise<{
+    success: boolean;
+    errCode: number;
+    reqType: string;
+    version: string;
+    taskId: string;
+} | void>;
 export declare const useResetMap: (devId: string) => {
     setResetMap: TSetResetMap;
 };

package/lib/mqtt/useResetMap.js

@@ -1,60 +1,31 @@
-// 重置地图
 import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
 import { normalResolve } from './promise';
 import { ResetCurrMapEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeResetMap0x42 } from '@ray-js/robot-protocol';
-
-// 重置地图响应类型
-
-// 设置重置地图函数类型定义
-
-/**
- * 自定义 Hook，用于重置地图
- * @param devId 设备ID
- * @returns 包含 setResetMap 函数的对象
- */
 export const useResetMap = devId => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
-  /**
-   * 重置地图
-   * @returns Promise<ResetMapResponse> 响应结果
-   */
+  // 重置地图
 
   return {
     setResetMap: () => {
-      try {
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: ResetCurrMapEnum.set
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(ResetCurrMapEnum.query, taskId);
-        }
-
-        // 非 MQTT 模式：使用命令传输
-        devices.common.model.actions.command_trans.set(encodeResetMap0x42({
-          version: commandVersion
-        }));
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: ResetCurrMapEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`
+      if (useMqtt) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: ResetCurrMapEnum.set
         });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to reset map');
+        ty.device.sendMqttMessage(params);
+        return normalResolve(ResetCurrMapEnum.query, params.message.taskId);
       }
+      devices.common.model.actions.command_trans.set(encodeResetMap0x42({
+        version: commandVersion
+      }));
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useRoomProperty.js

@@ -24,12 +24,16 @@ export const useRoomProperty = devId => {
       return normalResolve(RoomPropertyEnum.query, params.message.taskId);
     },
     setRoomProperty: message => {
-      // 参数验证
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomPropertyEnum.set,
+        message
+      });
       const {
         ids
       } = message;
       if (!isArray(ids) || isArray(ids) && ids.length === 0) {
-        throw new Error('ids is required and must be a non-empty array');
+        return Promise.reject(new Error('ids is required'));
       }
       const len = ids.length;
       const {
@@ -41,40 +45,29 @@ export const useRoomProperty = devId => {
         names = new Array(len).fill('')
       } = message;
       if (suctions && !isArray(suctions)) {
-        throw new Error('suctions is illegal');
+        // 设置超时定时器
+        return Promise.reject(new Error('cisterns is illegal'));
       }
       if (cisterns && !isArray(cisterns)) {
-        throw new Error('cisterns is illegal');
+        return Promise.reject(new Error('cisterns is illegal'));
       }
       if (cleanCounts && !isArray(cleanCounts)) {
-        throw new Error('cleanCounts is illegal');
+        return Promise.reject(new Error('cleanCounts is illegal'));
       }
       if (yMops && !isArray(yMops)) {
-        throw new Error('yMops is illegal');
+        return Promise.reject(new Error('yMops is illegal'));
       }
       if (sweepMopModes && !isArray(sweepMopModes)) {
-        throw new Error('sweepMopModes is illegal');
+        return Promise.reject(new Error('sweepMopModes is illegal'));
       }
       if (names && !isArray(names)) {
-        throw new Error('names is illegal');
+        return Promise.reject(new Error('names is illegal'));
       }
       if (len !== suctions.length || len !== cisterns.length || len !== cleanCounts.length || len !== yMops.length || len !== sweepMopModes.length || len !== names.length) {
-        throw new Error('The length of the parameters is inconsistent');
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: RoomPropertyEnum.set,
-          message
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(RoomPropertyEnum.query, taskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set room property');
+        return Promise.reject(new Error('The length of the parameters is inconsistent'));
       }
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomPropertyEnum.query, params.message.taskId);
     }
   };
 };

package/lib/mqtt/useSchedule.d.ts

@@ -1,4 +1,4 @@
-import { ScheduleEnum, RoomPreference, BaseResponse } from './type';
+import { RoomPreference, BaseResponse } from './type';
 type ScheduleItem = Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes' | 'ids'> & {
     active: number;
     cycle: number[];
@@ -9,22 +9,9 @@ interface Schedule {
     num: number;
     version?: string;
 }
-interface ScheduleResponse extends BaseResponse {
-    reqType: ScheduleEnum.query;
-    list: Array<ScheduleItem>;
-    num: number;
-}
-type TRequestSchedule = (message?: {
-    version?: string;
-}) => Promise<ScheduleResponse>;
-type TSetSchedule = (message: Schedule) => Promise<ScheduleResponse>;
-/**
- * 自定义 Hook，用于定时任务
- * @param devId 设备ID
- * @returns 包含 requestSchedule 和 setSchedule 函数的对象
- */
+type Response = BaseResponse & Schedule;
 export declare const useSchedule: (devId: string) => {
-    requestSchedule: TRequestSchedule;
-    setSchedule: TSetSchedule;
+    requestSchedule: () => Promise<Response>;
+    setSchedule: (message: Schedule) => Promise<Response | void>;
 };
 export {};

package/lib/mqtt/useSchedule.js

@@ -8,51 +8,39 @@ import { SingletonContext } from './mqttProvider';
 import { encodeDeviceTimer0x30 } from '@ray-js/robot-protocol';
 import { CISTERN_MAP, CLEAN_MODE_MAP, SUCTION_MAP } from '../constant';
 
-// 定时任务项
+// 定时任务
 
-// 定时任务数据
-
-// 定时任务响应类型
-
-// 请求定时数据函数类型定义
-
-// 设置定时数据函数类型定义
-
-/**
- * 自定义 Hook，用于定时任务
- * @param devId 设备ID
- * @returns 包含 requestSchedule 和 setSchedule 函数的对象
- */
 export const useSchedule = devId => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
-  /**
-   * 请求定时数据
-   * @param message 可选参数，包含版本号
-   * @returns Promise<ScheduleResponse> 响应结果
-   */
+  // 请求定时数据
 
-  /**
-   * 设置定时数据
-   * @param message 定时任务数据
-   * @returns Promise<ScheduleResponse> 响应结果
-   */
+  // 下发定时数据
 
   return {
     requestSchedule: function () {
       let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
         version: '1.0.0'
       };
-      if (!useMqtt) {
-        return Promise.reject(new Error('useMqtt is not used'));
-      }
-      try {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: ScheduleEnum.query,
+        message
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(ScheduleEnum.query, taskId);
+    },
+    setSchedule: message => {
+      if (useMqtt) {
         const params = createSetCommonParams({
           deviceId: devId,
-          reqType: ScheduleEnum.query,
+          reqType: ScheduleEnum.set,
           message
         });
         ty.device.sendMqttMessage(params);
@@ -60,79 +48,39 @@ export const useSchedule = devId => {
           taskId
         } = params.message;
         return normalResolve(ScheduleEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request schedule'));
-      }
-    },
-    setSchedule: message => {
-      // 参数验证
-      if (!message || typeof message.num !== 'number') {
-        throw new Error('message.num is required and must be a number');
-      }
-      if (!Array.isArray(message.list)) {
-        throw new Error('message.list is required and must be an array');
-      }
-      if (message.num !== message.list.length) {
-        throw new Error('message.num must equal message.list.length');
-      }
-      try {
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: ScheduleEnum.set,
-            message
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(ScheduleEnum.query, taskId);
-        }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodeDeviceTimer0x30({
-          version: commandVersion,
-          number: message.num,
-          list: message.list.map(_ref => {
-            let {
-              active,
-              suctions,
-              sweepMopModes,
-              ids,
-              cleanCounts,
-              cycle,
-              cisterns,
-              time
-            } = _ref;
-            return {
-              effectiveness: active,
-              cleanMode: CLEAN_MODE_MAP[sweepMopModes[0]],
-              fanLevel: SUCTION_MAP[suctions[0]],
-              waterLevel: CISTERN_MAP[cisterns[0]],
-              time: {
-                hour: time[0],
-                minute: time[1]
-              },
-              week: cycle,
-              sweepCount: cleanCounts[0],
-              roomIds: ids,
-              roomNum: ids.length
-            };
-          })
-        });
-        devices.common.model.actions.device_timer.set(command);
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: ScheduleEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          list: message.list,
-          num: message.num
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set schedule');
       }
+      const command = encodeDeviceTimer0x30({
+        version: commandVersion,
+        number: message.num,
+        list: message.list.map(_ref => {
+          let {
+            active,
+            suctions,
+            sweepMopModes,
+            ids,
+            cleanCounts,
+            cycle,
+            cisterns,
+            time
+          } = _ref;
+          return {
+            effectiveness: active,
+            cleanMode: CLEAN_MODE_MAP[sweepMopModes[0]],
+            fanLevel: SUCTION_MAP[suctions[0]],
+            waterLevel: CISTERN_MAP[cisterns[0]],
+            time: {
+              hour: time[0],
+              minute: time[1]
+            },
+            week: cycle,
+            sweepCount: cleanCounts[0],
+            roomIds: ids,
+            roomNum: ids.length
+          };
+        })
+      });
+      devices.common.model.actions.device_timer.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useSelectRoomClean.d.ts

@@ -1,30 +1,26 @@
-import { BaseResponse, RoomCleanSetEnum } from './type';
-interface RoomInfo {
-    roomId: number;
-    suction?: string;
-    cistern: string;
-    cleanTimes?: number;
-    yMop?: number;
-    sweepMopMode?: string;
-}
-interface RoomCleanResponse extends BaseResponse {
-    reqType: RoomCleanSetEnum.query;
+type Response = {
+    reqType: string;
+    version: string;
+    success: boolean;
+    errCode: number;
+    taskId: string;
     ids: number[];
     suctions?: string[];
     cisterns?: string[];
     cleanCounts?: number[];
     yMops?: number[];
     sweepMopModes?: string[];
-}
-type TSetRoomClean = (rooms: RoomInfo[]) => Promise<RoomCleanResponse>;
-type TRequestSelectRoomClean = () => Promise<RoomCleanResponse>;
-/**
- * 自定义 Hook，用于选区清扫
- * @param devId 设备ID
- * @returns 包含 requestSelectRoomClean 和 setRoomClean 函数的对象
- */
+};
+type TSetRoomClean = (rooms: {
+    roomId: number;
+    suction?: string;
+    cistern: string;
+    cleanTimes?: number;
+    yMop?: number;
+    sweepMopMode?: string;
+}[]) => Promise<Response> | Promise<void>;
 export declare const useSelectRoomClean: (devId: string) => {
-    requestSelectRoomClean: TRequestSelectRoomClean;
+    requestSelectRoomClean: () => Promise<Response>;
     setRoomClean: TSetRoomClean;
 };
 export {};