@ray-js/robot-data-stream 0.0.13-beta-10 → 0.0.13-beta-11

package/lib/mqtt/useCarpet.js

@@ -0,0 +1,169 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.every.js";
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { CarpetEnum } from './type/requestType';
+
+// 添加地毯的输入参数（批量添加）
+
+// 添加地毯响应类型
+
+// 更新地毯的输入参数
+
+// 查询地毯响应类型
+
+export const useCarpet = devId => {
+  /**
+   * 添加地毯（批量添加）
+   * @param carpetInfo 地毯信息，包含形状数组、轮廓点集合、数量、材质数组和清洁属性数组
+   * @returns Promise<AddCarpetResponse> 响应结果，包含返回的地毯ID
+   */
+
+  /**
+   * 更新地毯
+   * @param carpetInfo 地毯信息（id 必填，shape、type、cleanMode 可选）
+   * @returns Promise<BaseResponse> 响应结果
+   */
+
+  /**
+   * 删除地毯
+   * @param carpetId 地毯ID
+   * @returns Promise<BaseResponse> 响应结果
+   */
+
+  /**
+   * 查询地毯
+   * @returns Promise<CarpetQueryResponse> 响应结果，包含地毯数量、轮廓点集合、清洁属性和形状等信息
+   */
+
+  return {
+    addCarpet: carpetInfo => {
+      // 参数验证
+      if (!carpetInfo) {
+        throw new Error('carpetInfo is required');
+      }
+      if (!Array.isArray(carpetInfo.shape)) {
+        throw new Error('carpetInfo.shape is required and must be a non-empty array');
+      }
+      if (!carpetInfo.shape.every(s => ['rectangle', 'round'].includes(s))) {
+        throw new Error('carpetInfo.shape must contain only "rectangle" or "round"');
+      }
+      if (!Array.isArray(carpetInfo.polygons)) {
+        throw new Error('carpetInfo.polygons is required and must be a non-empty array');
+      }
+      if (typeof carpetInfo.num !== 'number') {
+        throw new Error('carpetInfo.num is required and must be a positive number');
+      }
+      if (!Array.isArray(carpetInfo.type)) {
+        throw new Error('carpetInfo.type is required and must be a non-empty array');
+      }
+      if (!Array.isArray(carpetInfo.cleanMode)) {
+        throw new Error('carpetInfo.cleanMode is required and must be a non-empty array');
+      }
+      try {
+        const sendData = {
+          shape: carpetInfo.shape,
+          polygons: carpetInfo.polygons,
+          num: carpetInfo.num,
+          type: carpetInfo.type,
+          cleanMode: carpetInfo.cleanMode
+        };
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: CarpetEnum.add,
+          message: {
+            carpetInfo: sendData
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return normalResolve(CarpetEnum.add, taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to add carpet');
+      }
+    },
+    updateCarpet: carpetInfo => {
+      // 参数验证：只验证 id，其他字段可选
+      if (!carpetInfo || !Array.isArray(carpetInfo.ids)) {
+        throw new Error('carpetInfo.ids is required and must be a array');
+      }
+
+      // 验证 shape 字段（如果提供）
+      if (carpetInfo.shape !== undefined && !carpetInfo.shape.every(s => ['rectangle', 'round'].includes(s))) {
+        throw new Error('carpetInfo.shape must be "rectangle" or "round"');
+      }
+      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;
+        }
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: CarpetEnum.update,
+          message: {
+            carpetInfo: sendData
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return normalResolve(CarpetEnum.update, taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to update carpet');
+      }
+    },
+    deleteCarpet: carpetIds => {
+      // 参数验证
+      if (!carpetIds || !Array.isArray(carpetIds)) {
+        throw new Error('carpetId is required and must be a number');
+      }
+      try {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: CarpetEnum.delete,
+          message: {
+            carpetInfo: {
+              ids: carpetIds
+            }
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return normalResolve(CarpetEnum.delete, taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to delete carpet');
+      }
+    },
+    queryCarpet: () => {
+      try {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: CarpetEnum.query
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return normalResolve(CarpetEnum.query, taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to query carpet');
+      }
+    }
+  };
+};

package/lib/mqtt/useCarpetClean.d.ts

@@ -0,0 +1,18 @@
+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>;
+/**
+ * 自定义 Hook，用于地毯清扫
+ * @param devId 设备ID
+ * @returns 包含 requestCarpetClean 和 setCarpetClean 函数的对象
+ */
+export declare const useCarpetClean: (devId: string) => {
+    requestCarpetClean: TRequestCarpetClean;
+    setCarpetClean: TSetCarpetClean;
+};
+export {};

package/lib/mqtt/useCarpetClean.js

@@ -0,0 +1,75 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+// 地毯清扫
+import { createSetCommonParams } from './createCommonOptions';
+import { CarpetCleanEnum } from './type/requestType';
+import { normalResolve } from './promise';
+
+// 地毯清扫响应类型
+
+// 设置地毯清扫函数类型定义
+
+// 请求地毯清扫函数类型定义
+
+/**
+ * 自定义 Hook，用于地毯清扫
+ * @param devId 设备ID
+ * @returns 包含 requestCarpetClean 和 setCarpetClean 函数的对象
+ */
+export const useCarpetClean = devId => {
+  /**
+   * 请求地毯清扫信息
+   * @returns Promise<CarpetCleanResponse> 响应结果
+   */
+
+  /**
+   * 设置地毯清扫
+   * @param carpetIds 地毯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'));
+      }
+    },
+    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`);
+        }
+      });
+      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,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/useDeviceModel.d.ts

@@ -0,0 +1,22 @@
+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) => {
+    requestDeviceList: TRequestDeviceList;
+    setDeviceModel: TSetDeviceModel;
+};
+export {};

package/lib/mqtt/useDeviceModel.js

@@ -0,0 +1,60 @@
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { DeviceModelEnum } from './type/requestType';
+
+// 请求设备列表函数定义
+
+// 设置设备模型函数定义
+
+export const useDeviceModel = devId => {
+  /**
+   * 请求设备列表
+   * @returns Promise<DeviceModelResponse> 响应结果
+   */
+
+  /**
+   * 设置设备模型
+   * @param modelInfos 设备模型信息数组
+   * @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'));
+      }
+    },
+    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');
+      }
+    }
+  };
+};

package/lib/mqtt/useFurnitureModel.d.ts

@@ -0,0 +1,21 @@
+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) => {
+    requestFurnitureList: TRequestFurnitureList;
+    setFurnitureModel: TSetFurnitureModel;
+};
+export {};

package/lib/mqtt/useFurnitureModel.js

@@ -0,0 +1,61 @@
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { FurnitureModelEnum } from './type/requestType';
+
+// 请求家具列表函数定义
+
+// 设置家具模型函数定义
+
+export const useFurnitureModel = devId => {
+  /**
+   * 请求家具列表
+   * @returns Promise<FurnitureModelResponse> 响应结果
+   */
+
+  /**
+   * 设置家具模型
+   * @param modelInfos 家具模型信息数组
+   * @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'));
+      }
+    },
+    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');
+      }
+    }
+  };
+};

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