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

package/lib/mqtt/type/requestType.d.ts

@@ -70,3 +70,6 @@ export declare enum UseMapEnum {
     query = "useMapRst",
     set = "useMapSet"
 }
+export declare enum DevInfoEnum {
+    query = "devInfoQry"
+}

package/lib/mqtt/type/requestType.js

@@ -104,4 +104,8 @@ export let UseMapEnum = /*#__PURE__*/function (UseMapEnum) {
   UseMapEnum["query"] = "useMapRst";
   UseMapEnum["set"] = "useMapSet";
   return UseMapEnum;
+}({});
+export let DevInfoEnum = /*#__PURE__*/function (DevInfoEnum) {
+  DevInfoEnum["query"] = "devInfoQry";
+  return DevInfoEnum;
 }({});

package/lib/mqtt/useDevInfo.d.ts

@@ -1,12 +1,7 @@
-interface DevInfoResponse {
-    reqType?: string;
-    version?: string;
+import { BaseResponse } from './type';
+export interface DevInfoResponse extends BaseResponse {
     info: string;
-    success?: boolean;
-    errCode?: number;
-    taskId?: string;
 }
 export declare const useDevInfo: (devId: string) => {
     requestDevInfo: () => Promise<DevInfoResponse>;
 };
-export {};

package/lib/mqtt/useDevInfo.js

@@ -1,12 +1,12 @@
+import { hexToUriDecodedString } from '@ray-js/robot-protocol';
 import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
 import { SingletonContext } from './mqttProvider';
 import { normalResolve } from './promise';
-import { hexToUriDecodedString } from '@ray-js/robot-protocol';
-var DevInfoEnum = /*#__PURE__*/function (DevInfoEnum) {
-  DevInfoEnum["query"] = "devInfoQry";
-  return DevInfoEnum;
-}(DevInfoEnum || {});
+import { DevInfoEnum } from './type';
+
+// 设备信息响应类型
+
 // 请求设备信息
 export const useDevInfo = devId => {
   const {
@@ -27,10 +27,26 @@ export const useDevInfo = devId => {
         } = params.message;
         return normalResolve(DevInfoEnum.query, taskId);
       }
-      const dpDevInfo = devices.common.model.props.device_info;
-      return Promise.resolve({
-        info: hexToUriDecodedString(dpDevInfo)
-      });
+
+      // 非 MQTT 模式：从设备属性中获取设备信息
+      try {
+        var _devices$common$model;
+        const dpDevInfo = (_devices$common$model = devices.common.model.props) === null || _devices$common$model === void 0 ? void 0 : _devices$common$model.device_info;
+        if (!dpDevInfo) {
+          return Promise.reject(new Error('Device info is not available in device properties'));
+        }
+        const info = hexToUriDecodedString(dpDevInfo);
+        return Promise.resolve({
+          info,
+          success: true,
+          errCode: 0,
+          reqType: DevInfoEnum.query,
+          version: '1.0.0',
+          taskId: `${Date.now()}`
+        });
+      } catch (error) {
+        return Promise.reject(error instanceof Error ? error : new Error('Failed to get device info from device properties'));
+      }
     }
   };
 };

package/lib/mqtt/useHistoryMap.d.ts

@@ -1,26 +1,18 @@
-type TDeleteHistoryMap = (mapId: number) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-}>;
-type TChangeCurrentMap = (mapId: number, url: string) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
+import { BaseResponse, DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
+interface DeleteMapResponse extends BaseResponse {
+    reqType: DeleteMapEnum.rst;
+}
+interface SaveMapResponse extends BaseResponse {
+    reqType: SaveCurrentMapEnum.query;
     mapId: number;
-    version: string;
-    taskId: string;
-}>;
-type TSaveMap = () => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
+}
+interface UseMapResponse extends BaseResponse {
+    reqType: UseMapEnum.query;
     mapId: number;
-    version: string;
-    taskId: string;
-} | void>;
+}
+type TDeleteHistoryMap = (mapId: number) => Promise<DeleteMapResponse>;
+type TSaveMap = () => Promise<SaveMapResponse>;
+type TChangeCurrentMap = (mapId: number, url: string) => Promise<UseMapResponse>;
 /**
  * 自定义 Hook，用于管理历史地图
  * @param devId 设备ID

package/lib/mqtt/useHistoryMap.js

@@ -6,8 +6,16 @@ import { DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeDeleteMap0x2c, encodeSaveMap0x2a, encodeUseMap0x2e } from '@ray-js/robot-protocol';
 
+// 删除历史地图响应类型
+
+// 保存地图响应类型
+
+// 更改当前地图响应类型
+
 // 删除历史地图函数类型定义
 
+// 保存当前地图函数类型定义
+
 // 更改当前使用的地图函数类型定义
 
 /**
@@ -18,32 +26,36 @@ import { encodeDeleteMap0x2c, encodeSaveMap0x2a, encodeUseMap0x2e } from '@ray-j
 export const useHistoryMap = devId => {
   const {
     useMqtt,
-    devices
+    devices,
+    commandVersion
   } = useContext(SingletonContext);
+
   /**
    * 删除历史地图
    * @param mapId 地图ID
-   * @returns Promise<{ success: boolean; errCode: number; reqType: string; version: string; taskId: string; }> 响应结果
+   * @returns Promise<DeleteMapResponse> 响应结果
    */
 
   /**
    * 保存当前地图
-   * @returns Promise<void> 响应结果
+   * @returns Promise<SaveMapResponse> 响应结果
    */
 
   /**
    * 更改当前使用的地图
    * @param mapId 地图ID
    * @param url 地图URL
-   * @returns Promise<{ success: boolean; errCode: number; reqType: string; mapId: number; version: string; taskId: string; }> 响应结果
+   * @returns Promise<UseMapResponse> 响应结果
    */
 
   return {
     deleteHistoryMap: async mapId => {
+      // 参数验证
+      if (!mapId || typeof mapId !== 'number') {
+        throw new Error('mapId is required and must be a number');
+      }
       try {
-        if (!mapId) {
-          return Promise.reject(new Error('mapId is required'));
-        }
+        // 先删除地图文件
         await deleteMultipleMapFile(mapId, devId);
         if (useMqtt) {
           const params = createSetCommonParams({
@@ -59,28 +71,41 @@ export const useHistoryMap = devId => {
           } = params.message;
           return normalResolve(DeleteMapEnum.rst, taskId);
         }
+
+        // 非 MQTT 模式：使用命令传输
         const command = encodeDeleteMap0x2c({
           id: mapId
         });
         devices.common.model.actions.command_trans.set(command);
-        return Promise.resolve();
-      } catch (err) {
-        return Promise.reject(err);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: DeleteMapEnum.rst,
+          version: commandVersion,
+          taskId: `${Date.now()}`
+        });
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to delete history map');
       }
     },
     changeCurrentMap: async (mapId, url) => {
+      // 参数验证
+      if (!mapId || typeof mapId !== 'number') {
+        throw new Error('mapId is required and must be a number');
+      }
+      if (!url || typeof url !== 'string') {
+        throw new Error('url is required and must be a string');
+      }
       try {
         if (useMqtt) {
-          const sendData = {
-            reqType: UseMapEnum.set,
-            mapId,
-            url,
-            urlLen: url.length
-          };
           const params = createSetCommonParams({
             deviceId: devId,
             reqType: UseMapEnum.set,
-            message: sendData
+            message: {
+              mapId,
+              url,
+              urlLen: url.length // URL 长度
+            }
           });
           ty.device.sendMqttMessage(params);
           const {
@@ -88,31 +113,56 @@ export const useHistoryMap = devId => {
           } = params.message;
           return normalResolve(UseMapEnum.query, taskId);
         }
+
+        // 非 MQTT 模式：使用命令传输
         const command = encodeUseMap0x2e({
           mapId,
           url
         });
         devices.common.model.actions.command_trans.set(command);
-        return Promise.resolve();
-      } catch (err) {
-        return Promise.reject(err);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: UseMapEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`,
+          mapId
+        });
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to change current map');
       }
     },
     saveMap: () => {
-      if (useMqtt) {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: SaveCurrentMapEnum.set,
-          message: {
-            oper: 0
-          }
+      try {
+        if (useMqtt) {
+          const params = createSetCommonParams({
+            deviceId: devId,
+            reqType: SaveCurrentMapEnum.set,
+            message: {
+              oper: 0 // 操作类型：0 表示保存
+            }
+          });
+          ty.device.sendMqttMessage(params);
+          const {
+            taskId
+          } = params.message;
+          return normalResolve(SaveCurrentMapEnum.query, taskId);
+        }
+
+        // 非 MQTT 模式：使用命令传输
+        const command = encodeSaveMap0x2a(1);
+        devices.common.model.actions.command_trans.set(command);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: SaveCurrentMapEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`,
+          mapId: 0 // 非 MQTT 模式下无法获取 mapId
         });
-        ty.device.sendMqttMessage(params);
-        return normalResolve(SaveCurrentMapEnum.query, params.message.taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to save current map');
       }
-      const command = encodeSaveMap0x2a(1);
-      devices.common.model.actions.command_trans.set(command);
-      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/usePartDivision.d.ts

@@ -1,11 +1,9 @@
 import { Point } from '../utils';
-type TSetPartDivision = (points: Point[], roomId: number, origin: Point) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-} | void>;
+import { BaseResponse, PartDivisionEnum } from './type';
+interface PartDivisionResponse extends BaseResponse {
+    reqType: PartDivisionEnum.query;
+}
+type TSetPartDivision = (points: Point[], roomId: number, origin: Point) => Promise<PartDivisionResponse>;
 /**
  * 自定义 Hook，用于房间分隔
  * @param devId 设备ID

package/lib/mqtt/usePartDivision.js

@@ -7,6 +7,8 @@ import { PartDivisionEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodePartitionDivision0x1c } from '@ray-js/robot-protocol';
 
+// 房间分隔响应类型
+
 // 设置房间分隔函数类型定义
 
 /**
@@ -24,38 +26,61 @@ export const usePartDivision = devId => {
   /**
    * 设置房间分隔
    * @param points 分隔点数组，SDK方法抛出来的坐标直接传入即可
-   * @param roomId 房间ID,当前要分隔的房间
+   * @param roomId 房间ID，当前要分隔的房间
    * @param origin 地图原点坐标
-   * @returns Promise<Response> 响应结果
+   * @returns Promise<PartDivisionResponse> 响应结果
    */
 
   return {
     setPartDivision: (points, roomId, origin) => {
-      if (useMqtt) {
-        try {
+      // 参数验证
+      if (!Array.isArray(points) || points.length === 0) {
+        throw new Error('points is required and must be a non-empty array');
+      }
+      if (typeof roomId !== 'number' || isNaN(roomId)) {
+        throw new Error('roomId is required and must be a valid number');
+      }
+      if (!origin || typeof origin.x !== 'number' || typeof origin.y !== 'number') {
+        throw new Error('origin is required and must be a valid Point object with x and y properties');
+      }
+      try {
+        if (useMqtt) {
+          // 将点数组转换为字符串格式
           const pointStr = pointsToString(points, origin);
           const params = createSetCommonParams({
             deviceId: devId,
             reqType: PartDivisionEnum.set,
             message: {
               lines: [pointStr],
-              ids: [roomId]
+              // 分隔线数组
+              ids: [roomId] // 房间ID数组
             }
           });
           ty.device.sendMqttMessage(params);
-          return normalResolve(PartDivisionEnum.query, params.message.taskId);
-        } catch (e) {
-          throw new Error('房间分隔失败');
+          const {
+            taskId
+          } = params.message;
+          return normalResolve(PartDivisionEnum.query, taskId);
         }
+
+        // 非 MQTT 模式：使用命令传输
+        const command = encodePartitionDivision0x1c({
+          version: commandVersion,
+          origin,
+          points,
+          roomId
+        });
+        devices.common.model.actions.command_trans.set(command);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: PartDivisionEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`
+        });
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to set part division');
       }
-      const command = encodePartitionDivision0x1c({
-        version: commandVersion,
-        origin,
-        points,
-        roomId
-      });
-      devices.common.model.actions.command_trans.set(command);
-      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/usePartMerge.d.ts

@@ -1,10 +1,8 @@
-type TSetPartMerge = (ids: number[]) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-} | void>;
+import { BaseResponse, PartMergeEnum } from './type';
+interface PartMergeResponse extends BaseResponse {
+    reqType: PartMergeEnum.query;
+}
+type TSetPartMerge = (ids: number[]) => Promise<PartMergeResponse>;
 /**
  * 自定义 Hook，用于分区合并
  * @param devId 设备ID

package/lib/mqtt/usePartMerge.js

@@ -8,6 +8,8 @@ import { PartMergeEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodePartitionMerge0x1e } from '@ray-js/robot-protocol';
 
+// 分区合并响应类型
+
 // 设置分区合并函数类型定义
 
 /**
@@ -24,34 +26,50 @@ export const usePartMerge = devId => {
   /**
    * 设置分区合并
    * @param ids 要合并的分区ID数组
-   * @returns Promise<Response> 响应结果
+   * @returns Promise<PartMergeResponse> 响应结果
    */
 
   return {
     setPartMerge: ids => {
+      // 参数验证
       if (!ids || ids.length < 2) {
-        return Promise.reject(new Error('ids is required and length must be greater than 1'));
+        throw new Error('ids is required and length must be greater than 1');
       }
       if (ids.some(id => typeof id !== 'number')) {
-        return Promise.reject(new Error('ids must be an array of numbers'));
+        throw new Error('ids must be an array of numbers');
       }
-      if (useMqtt) {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: PartMergeEnum.set,
-          message: {
-            ids
-          }
+      try {
+        if (useMqtt) {
+          const params = createSetCommonParams({
+            deviceId: devId,
+            reqType: PartMergeEnum.set,
+            message: {
+              ids
+            }
+          });
+          ty.device.sendMqttMessage(params);
+          const {
+            taskId
+          } = params.message;
+          return normalResolve(PartMergeEnum.query, taskId);
+        }
+
+        // 非 MQTT 模式：使用命令传输
+        const command = encodePartitionMerge0x1e({
+          version: commandVersion,
+          roomIds: ids
+        });
+        devices.common.model.actions.command_trans.set(command);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: PartMergeEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`
         });
-        ty.device.sendMqttMessage(params);
-        return normalResolve(PartMergeEnum.query, params.message.taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to set part merge');
       }
-      const command = encodePartitionMerge0x1e({
-        version: commandVersion,
-        roomIds: ids
-      });
-      devices.common.model.actions.command_trans.set(command);
-      return Promise.resolve();
     }
   };
 };

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 {};