@ray-js/robot-data-stream 0.0.14 → 0.0.15-beta.10

package/lib/mqtt/useDeviceModel.js

@@ -1,60 +1,49 @@
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
 import { DeviceModelEnum } from './type/requestType';
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
+/**
+ * 自定义 Hook，用于设备模型管理
+ * @returns 包含 requestDeviceList 和 setDeviceModel 函数的对象
+ */
+export const useDeviceModel = () => {
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
 
-// 请求设备列表函数定义
-
-// 设置设备模型函数定义
-
-export const useDeviceModel = devId => {
   /**
    * 请求设备列表
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<DeviceModelResponse> 响应结果
    */
 
   /**
    * 设置设备模型
-   * @param modelInfos 设备模型信息数组
+   * @param data 包含设备模型信息数组的对象
    * @returns Promise<DeviceModelResponse> 响应结果
    */
 
   return {
     requestDeviceList: () => {
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: DeviceModelEnum.query
-        });
-        const {
-          taskId
-        } = params.message;
-        ty.device.sendMqttMessage(params);
-        return normalResolve(DeviceModelEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request device list'));
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          sendStructuredMessage(DeviceModelEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request device list')));
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request device list'));
+        }
+      });
     },
-    setDeviceModel: modelInfos => {
-      // 参数验证
-      if (!Array.isArray(modelInfos)) {
-        throw new Error('modelInfos is required and must be an array');
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: DeviceModelEnum.set,
-          message: {
-            modelInfos
-          }
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(DeviceModelEnum.query, taskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set device model');
-      }
+    setDeviceModel: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_device_model', data);
+          sendStructuredMessage(DeviceModelEnum.set, {
+            modelInfos: validatedData
+          }, resolve, error => reject(handleMqttError(error, 'Failed to set device model')), DeviceModelEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set device model'));
+        }
+      });
     }
   };
 };

package/lib/mqtt/useFurnitureModel.d.ts

@@ -1,21 +1,9 @@
-import { BaseResponse } from './type';
-import { FurnitureModelEnum } from './type/requestType';
-interface FurnitureModelInfo {
-    id: number;
-    modelType: number;
-    scale: number;
-    size: [number, number, number];
-    rotation: [number, number, number];
-    position: [number, number, number];
-}
-interface FurnitureModelResponse extends BaseResponse {
-    reqType: FurnitureModelEnum.query;
-    modelInfo: FurnitureModelInfo[];
-}
-type TRequestFurnitureList = () => Promise<FurnitureModelResponse>;
-type TSetFurnitureModel = (modelInfos: FurnitureModelInfo[]) => Promise<FurnitureModelResponse>;
-export declare const useFurnitureModel: (devId: string) => {
+import { type TRequestFurnitureList, type TSetFurnitureModel } from './type/protocols';
+/**
+ * 自定义 Hook，用于家具模型管理
+ * @returns 包含 requestFurnitureList 和 setFurnitureModel 函数的对象
+ */
+export declare const useFurnitureModel: () => {
     requestFurnitureList: TRequestFurnitureList;
     setFurnitureModel: TSetFurnitureModel;
 };
-export {};

package/lib/mqtt/useFurnitureModel.js

@@ -1,61 +1,49 @@
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
 import { FurnitureModelEnum } from './type/requestType';
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
+/**
+ * 自定义 Hook，用于家具模型管理
+ * @returns 包含 requestFurnitureList 和 setFurnitureModel 函数的对象
+ */
+export const useFurnitureModel = () => {
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
 
-// 请求家具列表函数定义
-
-// 设置家具模型函数定义
-
-export const useFurnitureModel = devId => {
   /**
    * 请求家具列表
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<FurnitureModelResponse> 响应结果
    */
 
   /**
    * 设置家具模型
-   * @param modelInfos 家具模型信息数组
+   * @param data 包含家具模型信息数组的对象
    * @returns Promise<FurnitureModelResponse> 响应结果
    */
 
   return {
     requestFurnitureList: () => {
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: FurnitureModelEnum.query
-        });
-        const {
-          taskId
-        } = params.message;
-        ty.device.sendMqttMessage(params);
-        return normalResolve(FurnitureModelEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request furniture list'));
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          sendStructuredMessage(FurnitureModelEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request furniture list')));
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request furniture list'));
+        }
+      });
     },
-    setFurnitureModel: modelInfos => {
-      // 参数验证
-      if (!Array.isArray(modelInfos)) {
-        throw new Error('modelInfos is required and must be an array');
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: FurnitureModelEnum.set,
-          message: {
-            modelInfos
-          }
-        });
-        console.log('========================params', params);
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(FurnitureModelEnum.query, taskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set furniture model');
-      }
+    setFurnitureModel: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_furniture_model', data);
+          sendStructuredMessage(FurnitureModelEnum.set, {
+            modelInfos: validatedData
+          }, resolve, error => reject(handleMqttError(error, 'Failed to set furniture model')), FurnitureModelEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set furniture model'));
+        }
+      });
     }
   };
 };

package/lib/mqtt/useHistoryMap.d.ts

@@ -1,26 +1,10 @@
-import { BaseResponse, DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
-interface DeleteMapResponse extends BaseResponse {
-    reqType: DeleteMapEnum.rst;
-}
-interface SaveMapResponse extends BaseResponse {
-    reqType: SaveCurrentMapEnum.query;
-    mapId: number;
-}
-interface UseMapResponse extends BaseResponse {
-    reqType: UseMapEnum.query;
-    mapId: number;
-}
-type TDeleteHistoryMap = (mapId: number) => Promise<DeleteMapResponse>;
-type TSaveMap = () => Promise<SaveMapResponse>;
-type TChangeCurrentMap = (mapId: number, url: string) => Promise<UseMapResponse>;
+import { type TDeleteHistoryMap, type TSaveMap, type TChangeCurrentMap } from './type/protocols/historyMapProtocol';
 /**
  * 自定义 Hook，用于管理历史地图
- * @param devId 设备ID
  * @returns 包含删除历史地图、更改当前地图和保存地图的函数
  */
-export declare const useHistoryMap: (devId: string) => {
+export declare const useHistoryMap: () => {
     deleteHistoryMap: TDeleteHistoryMap;
     changeCurrentMap: TChangeCurrentMap;
     saveMap: TSaveMap;
 };
-export {};

package/lib/mqtt/useHistoryMap.js

@@ -1,35 +1,26 @@
 import { useContext } from 'react';
 import { deleteMultipleMapFile } from '../api/deleteMultipleMapFile';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
 import { DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeDeleteMap0x2c, encodeSaveMap0x2a, encodeUseMap0x2e } from '@ray-js/robot-protocol';
-
-// 删除历史地图响应类型
-
-// 保存地图响应类型
-
-// 更改当前地图响应类型
-
-// 删除历史地图函数类型定义
-
-// 保存当前地图函数类型定义
-
-// 更改当前使用的地图函数类型定义
-
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
 /**
  * 自定义 Hook，用于管理历史地图
- * @param devId 设备ID
  * @returns 包含删除历史地图、更改当前地图和保存地图的函数
  */
-export const useHistoryMap = devId => {
+export const useHistoryMap = () => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
-
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
+  const {
+    devId
+  } = devices.common.getDevInfo();
   /**
    * 删除历史地图
    * @param mapId 地图ID
@@ -38,6 +29,7 @@ export const useHistoryMap = devId => {
 
   /**
    * 保存当前地图
+   * @param data 包含操作类型的参数对象（可选，默认为 oper: 0）
    * @returns Promise<SaveMapResponse> 响应结果
    */
 
@@ -50,119 +42,110 @@ export const useHistoryMap = devId => {
 
   return {
     deleteHistoryMap: async mapId => {
-      // 参数验证
-      if (!mapId || typeof mapId !== 'number') {
-        throw new Error('mapId is required and must be a number');
-      }
-      try {
-        // 先删除地图文件
-        await deleteMultipleMapFile(mapId, devId);
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: DeleteMapEnum.set,
-            message: {
+      return new Promise((resolve, reject) => {
+        (async () => {
+          try {
+            // 使用 TypeBox Schema 进行参数验证
+            const validatedData = validator.validate('delete_history_map', {
               mapId
+            });
+
+            // 先删除地图文件
+            await deleteMultipleMapFile(validatedData.mapId, devId);
+            if (useMqtt) {
+              sendStructuredMessage(DeleteMapEnum.set, {
+                mapId: validatedData.mapId
+              }, resolve, error => reject(handleMqttError(error, 'Failed to delete history map')), DeleteMapEnum.rst // 响应类型是 rst，不是 set
+              );
+              return;
             }
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = 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');
-      }
+            // 非 MQTT 模式：使用命令传输
+            const command = encodeDeleteMap0x2c({
+              id: validatedData.mapId
+            });
+            devices.common.model.actions.command_trans.set(command);
+            resolve({
+              success: true,
+              errCode: 0,
+              reqType: DeleteMapEnum.rst,
+              version: commandVersion,
+              taskId: `${Date.now()}`
+            });
+          } catch (error) {
+            reject(handleMqttError(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 params = createSetCommonParams({
-            deviceId: devId,
-            reqType: UseMapEnum.set,
-            message: {
+      return new Promise((resolve, reject) => {
+        (async () => {
+          try {
+            // 构建符合 Schema 的数据
+            const mapData = {
               mapId,
               url,
-              urlLen: url.length // URL 长度
+              urlLen: url.length
+            };
+
+            // 使用 TypeBox Schema 进行参数验证
+            const validatedData = validator.validate('change_current_map', mapData);
+            if (useMqtt) {
+              sendStructuredMessage(UseMapEnum.set, validatedData, resolve, error => reject(handleMqttError(error, 'Failed to change current map')), UseMapEnum.query // 响应类型是 query，不是 set
+              );
+              return;
             }
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = 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');
-      }
+            // 非 MQTT 模式：使用命令传输
+            const command = encodeUseMap0x2e({
+              mapId: validatedData.mapId,
+              url: validatedData.url
+            });
+            devices.common.model.actions.command_trans.set(command);
+            resolve({
+              success: true,
+              errCode: 0,
+              reqType: UseMapEnum.query,
+              version: commandVersion,
+              taskId: `${Date.now()}`,
+              mapId: validatedData.mapId
+            });
+          } catch (error) {
+            reject(handleMqttError(error, 'Failed to change current map'));
+          }
+        })();
+      });
     },
-    saveMap: () => {
-      try {
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: SaveCurrentMapEnum.set,
-            message: {
-              oper: 0 // 操作类型：0 表示保存
-            }
+    saveMap: function () {
+      let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        oper: 0
+      };
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('save_map', data);
+          if (useMqtt) {
+            sendStructuredMessage(SaveCurrentMapEnum.set, validatedData, resolve, error => reject(handleMqttError(error, 'Failed to save current map')), SaveCurrentMapEnum.query // 响应类型是 query，不是 set
+            );
+            return;
+          }
+
+          // 非 MQTT 模式：使用命令传输
+          const command = encodeSaveMap0x2a(1);
+          devices.common.model.actions.command_trans.set(command);
+          resolve({
+            success: true,
+            errCode: 0,
+            reqType: SaveCurrentMapEnum.query,
+            version: commandVersion,
+            taskId: `${Date.now()}`,
+            mapId: 0 // 非 MQTT 模式下无法获取 mapId
           });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(SaveCurrentMapEnum.query, taskId);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to save current map'));
         }
-
-        // 非 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
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to save current map');
-      }
+      });
     }
   };
 };

package/lib/mqtt/usePartDivision.d.ts

@@ -1,15 +1,8 @@
-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>;
+import { type TSetPartDivision } from './type/protocols';
 /**
  * 自定义 Hook，用于房间分隔
- * @param devId 设备ID
  * @returns 包含 setPartDivision 函数的对象
  */
-export declare const usePartDivision: (devId: string) => {
+export declare const usePartDivision: () => {
     setPartDivision: TSetPartDivision;
 };
-export {};

package/lib/mqtt/usePartDivision.js

@@ -1,86 +1,77 @@
 // 房间分隔
+import { encodePartitionDivision0x1c } from '@ray-js/robot-protocol';
 import { useContext } from 'react';
 import { pointsToString } from '../utils';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
-import { PartDivisionEnum } from './type';
+import { handleMqttError, useStructuredMessage } from './hooks/useStructuredMessage';
 import { SingletonContext } from './mqttProvider';
-import { encodePartitionDivision0x1c } from '@ray-js/robot-protocol';
-
-// 房间分隔响应类型
-
-// 设置房间分隔函数类型定义
-
+import { PartDivisionEnum } from './type';
+import { validator } from './type/fun';
 /**
  * 自定义 Hook，用于房间分隔
- * @param devId 设备ID
  * @returns 包含 setPartDivision 函数的对象
  */
-export const usePartDivision = devId => {
+export const usePartDivision = () => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
 
   /**
    * 设置房间分隔
-   * @param points 分隔点数组，SDK方法抛出来的坐标直接传入即可
-   * @param roomId 房间ID，当前要分隔的房间
+   * @param points 分隔点数组
+   * @param roomId 房间ID，当前要分隔的房间（可以是 int 或 string）
    * @param origin 地图原点坐标
    * @returns Promise<PartDivisionResponse> 响应结果
    */
 
   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) {
-          // 将点数组转换为字符串格式
-          const pointStr = pointsToString(points, origin);
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: PartDivisionEnum.set,
-            message: {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用验证器验证三个独立参数
+          const validatedData = validator.validateSetPartDivision(points, roomId, origin);
+          const {
+            points: validatedPoints,
+            roomId: validatedRoomId,
+            origin: validatedOrigin
+          } = validatedData;
+          if (useMqtt) {
+            // 将点数组转换为字符串格式
+            const pointStr = pointsToString(validatedPoints, validatedOrigin);
+            sendStructuredMessage(PartDivisionEnum.set, {
               lines: [pointStr],
               // 分隔线数组
-              ids: [roomId] // 房间ID数组
-            }
+              ids: [validatedRoomId] // 房间ID数组
+            }, resolve, error => reject(handleMqttError(error, 'Failed to set part division')), PartDivisionEnum.query // 响应类型是 query，不是 set
+            );
+            return;
+          }
+
+          // 非 MQTT 模式：使用命令传输
+          // 将 roomId 转换为数字（如果它是字符串）
+          const roomIdNumber = typeof validatedRoomId === 'string' ? Number(validatedRoomId) : validatedRoomId;
+          const command = encodePartitionDivision0x1c({
+            version: commandVersion,
+            origin: validatedOrigin,
+            points: validatedPoints,
+            roomId: roomIdNumber
           });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(PartDivisionEnum.query, taskId);
+          devices.common.model.actions.command_trans.set(command);
+          resolve({
+            success: true,
+            errCode: 0,
+            reqType: PartDivisionEnum.query,
+            version: commandVersion,
+            taskId: `${Date.now()}`
+          });
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set part division'));
         }
-
-        // 非 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');
-      }
+      });
     }
   };
 };