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

package/lib/mqtt/type/index.js

@@ -1,14 +1,6 @@
 export * from './requestType';
 // 设备接口响应的统一标准结构
 
-/**
- * MQTT 协议号枚举
- */
-export let ProtocolEnum = /*#__PURE__*/function (ProtocolEnum) {
-  ProtocolEnum[ProtocolEnum["appToRobot"] = 64] = "appToRobot";
-  ProtocolEnum[ProtocolEnum["robotToApp"] = 65] = "robotToApp";
-  return ProtocolEnum;
-}({});
 export let PasswordEnum = /*#__PURE__*/function (PasswordEnum) {
   PasswordEnum["query"] = "passwordQry";
   PasswordEnum["set"] = "passwordSet";

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

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

package/lib/mqtt/type/requestType.js

@@ -104,8 +104,4 @@ 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,7 +1,12 @@
-import { BaseResponse } from './type';
-export interface DevInfoResponse extends BaseResponse {
+interface DevInfoResponse {
+    reqType?: string;
+    version?: string;
     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 { DevInfoEnum } from './type';
-
-// 设备信息响应类型
-
+import { hexToUriDecodedString } from '@ray-js/robot-protocol';
+var DevInfoEnum = /*#__PURE__*/function (DevInfoEnum) {
+  DevInfoEnum["query"] = "devInfoQry";
+  return DevInfoEnum;
+}(DevInfoEnum || {});
 // 请求设备信息
 export const useDevInfo = devId => {
   const {
@@ -27,26 +27,10 @@ export const useDevInfo = devId => {
         } = params.message;
         return normalResolve(DevInfoEnum.query, taskId);
       }
-
-      // 非 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'));
-      }
+      const dpDevInfo = devices.common.model.props.device_info;
+      return Promise.resolve({
+        info: hexToUriDecodedString(dpDevInfo)
+      });
     }
   };
 };

package/lib/mqtt/useHistoryMap.d.ts

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

package/lib/mqtt/useHistoryMap.js

@@ -6,16 +6,8 @@ import { DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeDeleteMap0x2c, encodeSaveMap0x2a, encodeUseMap0x2e } from '@ray-js/robot-protocol';
 
-// 删除历史地图响应类型
-
-// 保存地图响应类型
-
-// 更改当前地图响应类型
-
 // 删除历史地图函数类型定义
 
-// 保存当前地图函数类型定义
-
 // 更改当前使用的地图函数类型定义
 
 /**
@@ -26,36 +18,32 @@ import { encodeDeleteMap0x2c, encodeSaveMap0x2a, encodeUseMap0x2e } from '@ray-j
 export const useHistoryMap = devId => {
   const {
     useMqtt,
-    devices,
-    commandVersion
+    devices
   } = useContext(SingletonContext);
-
   /**
    * 删除历史地图
    * @param mapId 地图ID
-   * @returns Promise<DeleteMapResponse> 响应结果
+   * @returns Promise<{ success: boolean; errCode: number; reqType: string; version: string; taskId: string; }> 响应结果
    */
 
   /**
    * 保存当前地图
-   * @returns Promise<SaveMapResponse> 响应结果
+   * @returns Promise<void> 响应结果
    */
 
   /**
    * 更改当前使用的地图
    * @param mapId 地图ID
    * @param url 地图URL
-   * @returns Promise<UseMapResponse> 响应结果
+   * @returns Promise<{ success: boolean; errCode: number; reqType: string; mapId: number; version: string; taskId: string; }> 响应结果
    */
 
   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({
@@ -71,41 +59,28 @@ 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({
-          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');
+        return Promise.resolve();
+      } catch (err) {
+        return Promise.reject(err);
       }
     },
     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: {
-              mapId,
-              url,
-              urlLen: url.length // URL 长度
-            }
+            message: sendData
           });
           ty.device.sendMqttMessage(params);
           const {
@@ -113,56 +88,31 @@ 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({
-          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');
+        return Promise.resolve();
+      } catch (err) {
+        return Promise.reject(err);
       }
     },
     saveMap: () => {
-      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
+      if (useMqtt) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: SaveCurrentMapEnum.set,
+          message: {
+            oper: 0
+          }
         });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to save current map');
+        ty.device.sendMqttMessage(params);
+        return normalResolve(SaveCurrentMapEnum.query, params.message.taskId);
       }
+      const command = encodeSaveMap0x2a(1);
+      devices.common.model.actions.command_trans.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/usePartDivision.d.ts

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

package/lib/mqtt/usePartDivision.js

@@ -7,8 +7,6 @@ import { PartDivisionEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodePartitionDivision0x1c } from '@ray-js/robot-protocol';
 
-// 房间分隔响应类型
-
 // 设置房间分隔函数类型定义
 
 /**
@@ -26,61 +24,38 @@ export const usePartDivision = devId => {
   /**
    * 设置房间分隔
    * @param points 分隔点数组，SDK方法抛出来的坐标直接传入即可
-   * @param roomId 房间ID，当前要分隔的房间
+   * @param roomId 房间ID,当前要分隔的房间
    * @param origin 地图原点坐标
-   * @returns Promise<PartDivisionResponse> 响应结果
+   * @returns Promise<Response> 响应结果
    */
 
   return {
     setPartDivision: (points, roomId, origin) => {
-      // 参数验证
-      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) {
-          // 将点数组转换为字符串格式
+      if (useMqtt) {
+        try {
           const pointStr = pointsToString(points, origin);
           const params = createSetCommonParams({
             deviceId: devId,
             reqType: PartDivisionEnum.set,
             message: {
               lines: [pointStr],
-              // 分隔线数组
-              ids: [roomId] // 房间ID数组
+              ids: [roomId]
             }
           });
           ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(PartDivisionEnum.query, taskId);
+          return normalResolve(PartDivisionEnum.query, params.message.taskId);
+        } catch (e) {
+          throw new Error('房间分隔失败');
         }
-
-        // 非 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,8 +1,10 @@
-import { BaseResponse, PartMergeEnum } from './type';
-interface PartMergeResponse extends BaseResponse {
-    reqType: PartMergeEnum.query;
-}
-type TSetPartMerge = (ids: number[]) => Promise<PartMergeResponse>;
+type TSetPartMerge = (ids: number[]) => Promise<{
+    success: boolean;
+    errCode: number;
+    reqType: string;
+    version: string;
+    taskId: string;
+} | void>;
 /**
  * 自定义 Hook，用于分区合并
  * @param devId 设备ID

package/lib/mqtt/usePartMerge.js

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

package/lib/mqtt/usePassword.js

@@ -17,22 +17,13 @@ export const usePassword = devId => {
 
   return {
     requestPassword: () => {
-      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'));
-      }
+      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);
     },
     setPassword: _ref => {
       let {
@@ -40,55 +31,33 @@ export const usePassword = devId => {
         oldPassword,
         taskId
       } = _ref;
-      // 参数验证
-      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');
-      }
+      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);
     },
     checkPassword: _ref2 => {
       let {
         password,
         taskId
       } = _ref2;
-      // 参数验证
-      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');
-      }
+      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);
     }
   };
 };