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

package/lib/mqtt/useDevInfo.js

@@ -1,52 +1,60 @@
 import { hexToUriDecodedString } from '@ray-js/robot-protocol';
 import { useContext } from 'react';
-import { createSetCommonParams } from './createCommonOptions';
+import { handleMqttError, useStructuredMessage } from './hooks/useStructuredMessage';
 import { SingletonContext } from './mqttProvider';
-import { normalResolve } from './promise';
 import { DevInfoEnum } from './type';
 
-// 设备信息响应类型
+// 导出类型供外部使用
 
-// 请求设备信息
-export const useDevInfo = devId => {
+/**
+ * 自定义 Hook，用于设备信息管理
+ * @returns 包含 requestDevInfo 函数的对象
+ */
+export const useDevInfo = () => {
   const {
     useMqtt,
-    devices
+    devices,
+    commandVersion
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
+
+  /**
+   * 请求设备信息
+   * @returns Promise<DevInfoResponse> 响应结果，包含设备信息
+   */
+
   return {
     requestDevInfo: () => {
-      if (useMqtt) {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: DevInfoEnum.query,
-          message: {}
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(DevInfoEnum.query, taskId);
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          var _devices$common$model;
+          if (useMqtt) {
+            // request_dev_info 不需要参数，直接发送空对象
+            sendStructuredMessage(DevInfoEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request device info')));
+            return;
+          }
 
-      // 非 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'));
+          // 非 MQTT 模式：从设备属性中获取设备信息
+          const dpDevInfo = (_devices$common$model = devices.common.model.props) === null || _devices$common$model === void 0 ? void 0 : _devices$common$model.device_info;
+          if (!dpDevInfo) {
+            reject(new Error('Device info is not available in device properties'));
+            return;
+          }
+          const info = hexToUriDecodedString(dpDevInfo);
+          resolve({
+            info,
+            success: true,
+            errCode: 0,
+            reqType: DevInfoEnum.query,
+            version: commandVersion || '1.0.0',
+            taskId: `${Date.now()}`
+          });
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request device info'));
         }
-        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/useDeviceModel.d.ts

@@ -1,22 +1,9 @@
-import { BaseResponse } from './type';
-import { DeviceModelEnum } from './type/requestType';
-interface DeviceModelInfo {
-    id: number;
-    modelType: number;
-    scale: number;
-    size: [number, number, number];
-    rotation: [number, number, number];
-    position: [number, number, number];
-    subDevId: string;
-}
-interface DeviceModelResponse extends BaseResponse {
-    reqType: DeviceModelEnum.query;
-    modelInfo: DeviceModelInfo[];
-}
-type TRequestDeviceList = () => Promise<DeviceModelResponse>;
-type TSetDeviceModel = (modelInfos: DeviceModelInfo[]) => Promise<DeviceModelResponse>;
-export declare const useDeviceModel: (devId: string) => {
+import { type TRequestDeviceList, type TSetDeviceModel } from './type/protocols';
+/**
+ * 自定义 Hook，用于设备模型管理
+ * @returns 包含 requestDeviceList 和 setDeviceModel 函数的对象
+ */
+export declare const useDeviceModel: () => {
     requestDeviceList: TRequestDeviceList;
     setDeviceModel: TSetDeviceModel;
 };
-export {};

package/lib/mqtt/useDeviceModel.js

@@ -1,60 +1,47 @@
-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, 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,47 @@
-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, 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 {};