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

package/lib/mqtt/usePassword.js

@@ -17,13 +17,22 @@ export const usePassword = devId => {
 
   return {
     requestPassword: () => {
-      if (!useMqtt) return Promise.reject(new Error('useMqtt is not used'));
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: PasswordEnum.query
-      });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(PasswordEnum.query, params.message.taskId);
+      if (!useMqtt) {
+        return Promise.reject(new Error('useMqtt is not used'));
+      }
+      try {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: PasswordEnum.query
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return normalResolve(PasswordEnum.query, taskId);
+      } catch (error) {
+        return Promise.reject(error instanceof Error ? error : new Error('Failed to request password'));
+      }
     },
     setPassword: _ref => {
       let {
@@ -31,33 +40,55 @@ export const usePassword = devId => {
         oldPassword,
         taskId
       } = _ref;
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: PasswordEnum.set,
-        message: {
-          taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
-          password: md5(password).toString(),
-          oldPassword: oldPassword ? md5(oldPassword).toString() : undefined
-        }
-      });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(PasswordEnum.rst, params.message.taskId);
+      // 参数验证
+      if (!password || typeof password !== 'string') {
+        throw new Error('password is required and must be a string');
+      }
+      try {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: PasswordEnum.set,
+          message: {
+            taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
+            password: md5(password).toString(),
+            oldPassword: oldPassword ? md5(oldPassword).toString() : undefined
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId: finalTaskId
+        } = params.message;
+        return normalResolve(PasswordEnum.rst, finalTaskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to set password');
+      }
     },
     checkPassword: _ref2 => {
       let {
         password,
         taskId
       } = _ref2;
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: PasswordEnum.check,
-        message: {
-          taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
-          password: md5(password).toString()
-        }
-      });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(PasswordEnum.checkRst, params.message.taskId);
+      // 参数验证
+      if (!password || typeof password !== 'string') {
+        throw new Error('password is required and must be a string');
+      }
+      try {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: PasswordEnum.check,
+          message: {
+            taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
+            password: md5(password).toString()
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId: finalTaskId
+        } = params.message;
+        return normalResolve(PasswordEnum.checkRst, finalTaskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to check password');
+      }
     }
   };
 };

package/lib/mqtt/useQuiteHours.d.ts

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

package/lib/mqtt/useQuiteHours.js

@@ -1,6 +1,3 @@
-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';
@@ -9,8 +6,14 @@ import { QuietHoursEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeDoNotDisturb0x32 } from '@ray-js/robot-protocol';
 
+// 勿扰模式响应类型
+
+// 设置勿扰模式参数类型
+
 // 设置勿扰模式函数类型定义
 
+// 请求勿扰模式函数类型定义
+
 /**
  * 自定义 Hook，用于勿扰模式
  * @param devId 设备ID
@@ -24,69 +27,109 @@ export const useQuiteHours = devId => {
   } = useContext(SingletonContext);
   /**
    * 请求勿扰模式数据
-   * @returns Promise<{ time: string[]; day: number; active: number }> 响应结果
+   * @returns Promise<QuietHoursResponse> 响应结果
    */
 
   /**
    * 设置勿扰模式
-   * @param message 包含勿扰模式设置参数的对象
-   * @returns Promise<Response> 响应结果
+   * @param params 包含勿扰模式设置参数的对象
+   * @returns Promise<QuietHoursResponse> 响应结果
    */
 
   return {
-    setQuiteHours: message => {
+    setQuiteHours: params => {
       const {
-          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');
+        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);
         }
+
+        // 非 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.set,
-          message: _objectSpread({
-            time: [`${h0},${m0}`, `${h1},${m1}`]
-          }, others)
+          reqType: QuietHoursEnum.query
         });
         ty.device.sendMqttMessage(params);
-        return normalResolve(QuietHoursEnum.query, params.message.taskId);
+        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'));
       }
-      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,10 +1,13 @@
-type TSetResetMap = () => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-} | void>;
+import { BaseResponse, ResetCurrMapEnum } from './type';
+interface ResetMapResponse extends BaseResponse {
+    reqType: ResetCurrMapEnum.query;
+}
+type TSetResetMap = () => Promise<ResetMapResponse>;
+/**
+ * 自定义 Hook，用于重置地图
+ * @param devId 设备ID
+ * @returns 包含 setResetMap 函数的对象
+ */
 export declare const useResetMap: (devId: string) => {
     setResetMap: TSetResetMap;
 };

package/lib/mqtt/useResetMap.js

@@ -1,31 +1,60 @@
+// 重置地图
 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: () => {
-      if (useMqtt) {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: ResetCurrMapEnum.set
+      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()}`
         });
-        ty.device.sendMqttMessage(params);
-        return normalResolve(ResetCurrMapEnum.query, params.message.taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to reset map');
       }
-      devices.common.model.actions.command_trans.set(encodeResetMap0x42({
-        version: commandVersion
-      }));
-      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useRoomProperty.js

@@ -24,16 +24,12 @@ 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) {
-        return Promise.reject(new Error('ids is required'));
+        throw new Error('ids is required and must be a non-empty array');
       }
       const len = ids.length;
       const {
@@ -45,29 +41,40 @@ export const useRoomProperty = devId => {
         names = new Array(len).fill('')
       } = message;
       if (suctions && !isArray(suctions)) {
-        // 设置超时定时器
-        return Promise.reject(new Error('cisterns is illegal'));
+        throw new Error('suctions is illegal');
       }
       if (cisterns && !isArray(cisterns)) {
-        return Promise.reject(new Error('cisterns is illegal'));
+        throw new Error('cisterns is illegal');
       }
       if (cleanCounts && !isArray(cleanCounts)) {
-        return Promise.reject(new Error('cleanCounts is illegal'));
+        throw new Error('cleanCounts is illegal');
       }
       if (yMops && !isArray(yMops)) {
-        return Promise.reject(new Error('yMops is illegal'));
+        throw new Error('yMops is illegal');
       }
       if (sweepMopModes && !isArray(sweepMopModes)) {
-        return Promise.reject(new Error('sweepMopModes is illegal'));
+        throw new Error('sweepMopModes is illegal');
       }
       if (names && !isArray(names)) {
-        return Promise.reject(new Error('names is illegal'));
+        throw new Error('names is illegal');
       }
       if (len !== suctions.length || len !== cisterns.length || len !== cleanCounts.length || len !== yMops.length || len !== sweepMopModes.length || len !== names.length) {
-        return Promise.reject(new Error('The length of the parameters is inconsistent'));
+        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');
       }
-      ty.device.sendMqttMessage(params);
-      return normalResolve(RoomPropertyEnum.query, params.message.taskId);
     }
   };
 };

package/lib/mqtt/useSchedule.d.ts

@@ -1,4 +1,4 @@
-import { RoomPreference, BaseResponse } from './type';
+import { ScheduleEnum, RoomPreference, BaseResponse } from './type';
 type ScheduleItem = Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes' | 'ids'> & {
     active: number;
     cycle: number[];
@@ -9,9 +9,22 @@ interface Schedule {
     num: number;
     version?: string;
 }
-type Response = BaseResponse & Schedule;
+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 函数的对象
+ */
 export declare const useSchedule: (devId: string) => {
-    requestSchedule: () => Promise<Response>;
-    setSchedule: (message: Schedule) => Promise<Response | void>;
+    requestSchedule: TRequestSchedule;
+    setSchedule: TSetSchedule;
 };
 export {};