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

package/lib/mqtt/useCarpet.js

@@ -1,51 +1,21 @@
-import "core-js/modules/esnext.iterator.constructor.js";
-import "core-js/modules/esnext.iterator.every.js";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import "core-js/modules/esnext.iterator.map.js";
 import { pointsToString } from '../utils';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
+import { pickBy } from 'lodash-es';
 import { CarpetEnum } from './type/requestType';
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
 
-// 公共的地毯属性类型
+// 导出类型供外部使用
 
-// 形状类型定义
-
-// 添加地毯的输入参数（批量添加）
-
-// 添加地毯响应类型
-
-// 更新地毯的输入参数
-
-// 更新地毯发送数据的类型（polygons 已转换为字符串）
-
-// 查询地毯响应类型
-
-// 设置地毯的输入参数
-
-// 设置地毯响应类型
-
-// 验证形状数组的辅助函数
-const validateShape = function (shape, allowedShapes) {
-  let fieldName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'shape';
-  if (!shape.every(s => allowedShapes.includes(s))) {
-    throw new Error(`${fieldName} must contain only ${allowedShapes.map(s => `"${s}"`).join(', ')}`);
-  }
-};
-
-// 发送 MQTT 消息并返回 Promise 的辅助函数
-const sendMqttMessage = (devId, reqType, message) => {
-  const params = createSetCommonParams({
-    deviceId: devId,
-    reqType,
-    message
-  });
-  ty.device.sendMqttMessage(params);
+/**
+ * 自定义 Hook，用于地毯管理
+ * @returns 包含 addCarpet、updateCarpet、deleteCarpet、queryCarpet、setCarpet 函数的对象
+ */
+export const useCarpet = () => {
   const {
-    taskId
-  } = params.message;
-  return normalResolve(reqType, taskId);
-};
-export const useCarpet = devId => {
+    sendStructuredMessage
+  } = useStructuredMessage();
   /**
    * 添加地毯（批量添加）
    * @param carpetInfo 地毯信息，包含形状数组、轮廓点集合、数量、材质数组和清洁属性数组
@@ -54,172 +24,122 @@ export const useCarpet = devId => {
 
   /**
    * 更新地毯
-   * @param carpetInfo 地毯信息（id 必填，shape、type、cleanMode 可选）
+   * @param carpetInfo 地毯信息（ids 必填，shape、type、cleanMode 可选）
    * @returns Promise<BaseResponse> 响应结果
    */
 
   /**
    * 删除地毯
-   * @param carpetId 地毯ID
+   * @param data 包含地毯ID数组的对象
    * @returns Promise<BaseResponse> 响应结果
    */
 
   /**
    * 查询地毯
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<CarpetQueryResponse> 响应结果，包含地毯数量、轮廓点集合、清洁属性和形状等信息
    */
 
   /**
    * 设置地毯（一次性设置所有地毯）
    * @param carpetInfo 地毯信息，包含数量、轮廓点集合、清洁属性、形状和ID等
-   * @returns Promise<SetCarpetResponse> 响应结果，包含设置后的地毯信息
+   * @returns Promise<CarpetQueryResponse> 响应结果，包含设置后的地毯信息
    */
 
   return {
     addCarpet: carpetInfo => {
-      // 参数验证
-      if (!carpetInfo) {
-        throw new Error('carpetInfo is required');
-      }
-      if (!Array.isArray(carpetInfo.shape) || carpetInfo.shape.length === 0) {
-        throw new Error('carpetInfo.shape is required and must be a non-empty array');
-      }
-      validateShape(carpetInfo.shape, ['rectangle', 'round'], 'carpetInfo.shape');
-      if (!Array.isArray(carpetInfo.polygons) || carpetInfo.polygons.length === 0) {
-        throw new Error('carpetInfo.polygons is required and must be a non-empty array');
-      }
-      if (typeof carpetInfo.num !== 'number' || carpetInfo.num <= 0) {
-        throw new Error('carpetInfo.num is required and must be a positive number');
-      }
-      if (!Array.isArray(carpetInfo.type) || carpetInfo.type.length === 0) {
-        throw new Error('carpetInfo.type is required and must be a non-empty array');
-      }
-      if (!Array.isArray(carpetInfo.cleanMode) || carpetInfo.cleanMode.length === 0) {
-        throw new Error('carpetInfo.cleanMode is required and must be a non-empty array');
-      }
-      try {
-        const sendData = {
-          shape: carpetInfo.shape,
-          polygons: carpetInfo.polygons.map(i => pointsToString(i)),
-          num: carpetInfo.num,
-          type: carpetInfo.type,
-          cleanMode: carpetInfo.cleanMode,
-          autoBoost: carpetInfo.autoBoost,
-          fineCleaning: carpetInfo.fineCleaning,
-          sideBrushRotating: carpetInfo.sideBrushRotating
-        };
-        return sendMqttMessage(devId, CarpetEnum.add, {
-          carpetInfo: sendData
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to add carpet');
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('add_carpet', carpetInfo);
+          const sendData = {
+            shape: validatedData.shape,
+            polygons: validatedData.polygons.map(i => pointsToString(i)),
+            num: validatedData.num,
+            type: validatedData.type,
+            cleanMode: validatedData.cleanMode,
+            autoBoost: validatedData.autoBoost,
+            fineCleaning: validatedData.fineCleaning,
+            sideBrushRotating: validatedData.sideBrushRotating
+          };
+          sendStructuredMessage(CarpetEnum.add, {
+            carpetInfo: sendData
+          }, resolve, error => reject(handleMqttError(error, 'Failed to add carpet')));
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to add carpet'));
+        }
+      });
     },
     updateCarpet: carpetInfo => {
-      // 参数验证：只验证 id，其他字段可选
-      if (!carpetInfo || !Array.isArray(carpetInfo.ids) || carpetInfo.ids.length === 0) {
-        throw new Error('carpetInfo.ids is required and must be a non-empty array');
-      }
-
-      // 验证 shape 字段（如果提供）
-      if (carpetInfo.shape !== undefined) {
-        validateShape(carpetInfo.shape, ['rectangle', 'round'], 'carpetInfo.shape');
-      }
-      try {
-        // 构建发送数据，只包含传入的字段
-        const sendData = {
-          ids: carpetInfo.ids
-        };
-
-        // 可选字段：如果存在则添加
-        if (carpetInfo.shape !== undefined) {
-          sendData.shape = carpetInfo.shape;
-        }
-        if (carpetInfo.type !== undefined) {
-          sendData.type = carpetInfo.type;
-        }
-        if (carpetInfo.cleanMode !== undefined) {
-          sendData.cleanMode = carpetInfo.cleanMode;
-        }
-        if (carpetInfo.autoBoost !== undefined) {
-          sendData.autoBoost = carpetInfo.autoBoost;
-        }
-        if (carpetInfo.fineCleaning !== undefined) {
-          sendData.fineCleaning = carpetInfo.fineCleaning;
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('update_carpet', carpetInfo);
+
+          // 构建发送数据，只包含传入的字段
+          // 先处理需要特殊转换的字段
+          const processedData = _objectSpread(_objectSpread({}, validatedData), validatedData.polygons !== undefined && {
+            polygons: validatedData.polygons.map(i => pointsToString(i))
+          });
+
+          // 使用 lodash pickBy 过滤掉 undefined 值
+          const sendData = pickBy(processedData, value => value !== undefined);
+          sendStructuredMessage(CarpetEnum.update, {
+            carpetInfo: sendData
+          }, resolve, error => reject(handleMqttError(error, 'Failed to update carpet')), CarpetEnum.update);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to update carpet'));
         }
-        if (carpetInfo.sideBrushRotating !== undefined) {
-          sendData.sideBrushRotating = carpetInfo.sideBrushRotating;
-        }
-        // 特殊处理 polygons（需要转换）
-        if (carpetInfo.polygons !== undefined) {
-          sendData.polygons = carpetInfo.polygons.map(i => pointsToString(i));
-        }
-        return sendMqttMessage(devId, CarpetEnum.update, {
-          carpetInfo: sendData
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to update carpet');
-      }
+      });
     },
-    deleteCarpet: carpetIds => {
-      // 参数验证
-      if (!Array.isArray(carpetIds) || carpetIds.length === 0) {
-        throw new Error('carpetIds is required and must be a non-empty array');
-      }
-      try {
-        return sendMqttMessage(devId, CarpetEnum.delete, {
-          carpetInfo: {
-            ids: carpetIds
-          }
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to delete carpet');
-      }
+    deleteCarpet: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('delete_carpet', data);
+          sendStructuredMessage(CarpetEnum.delete, {
+            carpetInfo: {
+              ids: validatedData.ids
+            }
+          }, resolve, error => reject(handleMqttError(error, 'Failed to delete carpet')), CarpetEnum.delete);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to delete carpet'));
+        }
+      });
     },
-    queryCarpet: () => {
-      try {
-        return sendMqttMessage(devId, CarpetEnum.query, {});
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to query carpet');
-      }
+    queryCarpet: function () {
+      let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedParams = validator.validate('query_carpet', data);
+          sendStructuredMessage(CarpetEnum.query, validatedParams, resolve, error => reject(handleMqttError(error, 'Failed to query carpet')), CarpetEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to query carpet'));
+        }
+      });
     },
     setCarpet: carpetInfo => {
-      // 参数验证
-      if (!carpetInfo) {
-        throw new Error('carpetInfo is required');
-      }
-      if (typeof carpetInfo.num !== 'number' || carpetInfo.num <= 0) {
-        throw new Error('carpetInfo.num is required and must be a positive number');
-      }
-      if (!Array.isArray(carpetInfo.polygons) || carpetInfo.polygons.length === 0) {
-        throw new Error('carpetInfo.polygons is required and must be a non-empty array');
-      }
-      if (!Array.isArray(carpetInfo.cleanMode) || carpetInfo.cleanMode.length === 0) {
-        throw new Error('carpetInfo.cleanMode is required and must be a non-empty array');
-      }
-      if (!Array.isArray(carpetInfo.shape) || carpetInfo.shape.length === 0) {
-        throw new Error('carpetInfo.shape is required and must be a non-empty array');
-      }
-      validateShape(carpetInfo.shape, ['rectangle', 'round', 'custom'], 'carpetInfo.shape');
-      if (!Array.isArray(carpetInfo.ids) || carpetInfo.ids.length === 0) {
-        throw new Error('carpetInfo.ids is required and must be a non-empty array');
-      }
-      try {
-        const sendData = {
-          num: carpetInfo.num,
-          polygons: carpetInfo.polygons.map(i => pointsToString(i)),
-          cleanMode: carpetInfo.cleanMode,
-          autoBoost: carpetInfo.autoBoost,
-          fineCleaning: carpetInfo.fineCleaning,
-          sideBrushRotating: carpetInfo.sideBrushRotating,
-          shape: carpetInfo.shape,
-          ids: carpetInfo.ids,
-          type: carpetInfo.type
-        };
-        return sendMqttMessage(devId, CarpetEnum.set, sendData);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set carpet');
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_carpet', carpetInfo);
+          const sendData = {
+            num: validatedData.num,
+            polygons: validatedData.polygons.map(i => pointsToString(i)),
+            cleanMode: validatedData.cleanMode,
+            autoBoost: validatedData.autoBoost,
+            fineCleaning: validatedData.fineCleaning,
+            sideBrushRotating: validatedData.sideBrushRotating,
+            shape: validatedData.shape,
+            ids: validatedData.ids,
+            type: validatedData.type
+          };
+          sendStructuredMessage(CarpetEnum.set, sendData, resolve, error => reject(handleMqttError(error, 'Failed to set carpet')), CarpetEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set carpet'));
+        }
+      });
     }
   };
 };

package/lib/mqtt/useCarpetClean.d.ts

@@ -1,18 +1,9 @@
-import { BaseResponse } from './type';
-import { CarpetCleanEnum } from './type/requestType';
-interface CarpetCleanResponse extends BaseResponse {
-    reqType: CarpetCleanEnum;
-    ids: number[];
-}
-type TSetCarpetClean = (carpetIds: number[]) => Promise<CarpetCleanResponse>;
-type TRequestCarpetClean = () => Promise<CarpetCleanResponse>;
+import { type TRequestCarpetClean, type TSetCarpetClean } from './type/protocols';
 /**
  * 自定义 Hook，用于地毯清扫
- * @param devId 设备ID
  * @returns 包含 requestCarpetClean 和 setCarpetClean 函数的对象
  */
-export declare const useCarpetClean: (devId: string) => {
+export declare const useCarpetClean: () => {
     requestCarpetClean: TRequestCarpetClean;
     setCarpetClean: TSetCarpetClean;
 };
-export {};

package/lib/mqtt/useCarpetClean.js

@@ -1,75 +1,51 @@
-import "core-js/modules/esnext.iterator.constructor.js";
-import "core-js/modules/esnext.iterator.for-each.js";
 // 地毯清扫
-import { createSetCommonParams } from './createCommonOptions';
+import { handleMqttError, useStructuredMessage } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
 import { CarpetCleanEnum } from './type/requestType';
-import { normalResolve } from './promise';
-
-// 地毯清扫响应类型
-
-// 设置地毯清扫函数类型定义
-
-// 请求地毯清扫函数类型定义
 
 /**
  * 自定义 Hook，用于地毯清扫
- * @param devId 设备ID
  * @returns 包含 requestCarpetClean 和 setCarpetClean 函数的对象
  */
-export const useCarpetClean = devId => {
+export const useCarpetClean = () => {
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
+
   /**
    * 请求地毯清扫信息
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<CarpetCleanResponse> 响应结果
    */
 
   /**
    * 设置地毯清扫
-   * @param carpetIds 地毯ID数组
+   * @param data 包含地毯ID数组的对象
    * @returns Promise<CarpetCleanResponse> 响应结果
    */
 
   return {
     requestCarpetClean: () => {
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: CarpetCleanEnum.query
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(CarpetCleanEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request carpet clean'));
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          sendStructuredMessage(CarpetCleanEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request carpet clean')), CarpetCleanEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request carpet clean'));
+        }
+      });
     },
-    setCarpetClean: carpetIds => {
-      // 参数验证
-      if (!Array.isArray(carpetIds) || carpetIds.length === 0) {
-        throw new Error('carpetIds is required and must be a non-empty array');
-      }
-      carpetIds.forEach((id, index) => {
-        if (typeof id !== 'number') {
-          throw new Error(`carpetIds[${index}] must be a number`);
+    setCarpetClean: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_carpet_clean', data);
+          sendStructuredMessage(CarpetCleanEnum.set, {
+            ids: validatedData
+          }, resolve, error => reject(handleMqttError(error, 'Failed to set carpet clean')), CarpetCleanEnum.set);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set carpet clean'));
         }
       });
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: CarpetCleanEnum.set,
-          message: {
-            ids: carpetIds
-          }
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(CarpetCleanEnum.set, taskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set carpet clean');
-      }
     }
   };
 };

package/lib/mqtt/useDevInfo.d.ts

@@ -1,7 +1,9 @@
-import { BaseResponse } from './type';
-export interface DevInfoResponse extends BaseResponse {
-    info: string;
-}
-export declare const useDevInfo: (devId: string) => {
-    requestDevInfo: () => Promise<DevInfoResponse>;
+import { type TRequestDevInfo } from './type/protocols/devInfoProtocol';
+export type { DevInfoResponse } from './type/protocols/devInfoProtocol';
+/**
+ * 自定义 Hook，用于设备信息管理
+ * @returns 包含 requestDevInfo 函数的对象
+ */
+export declare const useDevInfo: () => {
+    requestDevInfo: TRequestDevInfo;
 };

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