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

package/lib/mqtt/useVirtualArea.js

@@ -1,6 +1,5 @@
 import "core-js/modules/esnext.iterator.constructor.js";
 import "core-js/modules/esnext.iterator.for-each.js";
-import "core-js/modules/esnext.iterator.map.js";
 // 添加禁区
 import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
@@ -9,9 +8,6 @@ import { VirtualAreaEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeVirtualArea0x1a, requestVirtualArea0x1b } from '@ray-js/robot-protocol';
 import { pointsToString } from '../utils';
-
-// 虚拟区域响应类型
-
 // 禁区
 
 export const useVirtualArea = devId => {
@@ -29,132 +25,66 @@ export const useVirtualArea = devId => {
   /**
    * 设置虚拟区域数据
    * @param message 包含虚拟区域设置参数的对象
-   * @param message.data 虚拟区域的数据数组
-   * @param message.origin 原点坐标
+   * @param message.polygons 多边形数组，每个元素为一个多边形的坐标字符串
+   * @param message.names 名称数组，每个元素为一个区域的名称
+   * @param message.modes 模式数组，每个元素为一个区域的模式，0:全禁，1:禁扫，2:禁拖
+   * @param message.num 虚拟区域的数量
    * @returns Promise<VirtualAreaResponse> 响应结果
    */
 
   return {
     requestVirtualArea: () => {
-      try {
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: VirtualAreaEnum.query
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(VirtualAreaEnum.query, taskId);
-        }
-
-        // 非 MQTT 模式：使用命令传输
-        devices.common.model.actions.command_trans.set(requestVirtualArea0x1b({
-          version: commandVersion
-        }));
-
-        // 非 MQTT 模式下无法立即获取响应数据，返回默认响应
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: VirtualAreaEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          num: 0,
-          modes: [],
-          polygons: [],
-          names: [],
-          mapId: 0
+      if (useMqtt) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualAreaEnum.query
         });
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request virtual area'));
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualAreaEnum.query, params.message.taskId);
       }
+      return devices.common.model.actions.command_trans.set(requestVirtualArea0x1b({
+        version: commandVersion
+      }));
     },
     setVirtualArea: _ref => {
       let {
         data,
         origin
       } = _ref;
-      // 参数验证
-      if (!Array.isArray(data) || data.length === 0) {
-        throw new Error('data is required and must be a non-empty array');
-      }
-      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 names = [];
-          const modes = [];
-          const polygons = [];
-          data.forEach(_ref2 => {
-            let {
-              points,
-              name,
-              mode
-            } = _ref2;
-            names.push(name);
-            modes.push(mode);
-            polygons.push(pointsToString(points, origin));
-          });
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: VirtualAreaEnum.set,
-            message: {
-              polygons,
-              num: data.length,
-              modes: modes,
-              names: names
-            }
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(VirtualAreaEnum.query, taskId);
-        }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodeVirtualArea0x1a({
-          version: commandVersion,
-          origin,
-          virtualAreas: data
-        });
-        devices.common.model.actions.command_trans.set(command);
-        const names = data.map(_ref3 => {
-          let {
-            name
-          } = _ref3;
-          return name;
-        });
-        const modes = data.map(_ref4 => {
+      if (useMqtt) {
+        const names = [];
+        const modes = [];
+        const polygons = [];
+        data.forEach(_ref2 => {
           let {
+            points,
+            name,
             mode
-          } = _ref4;
-          return mode;
-        });
-        const polygons = data.map(_ref5 => {
-          let {
-            points
-          } = _ref5;
-          return pointsToString(points, origin);
+          } = _ref2;
+          names.push(name);
+          modes.push(mode);
+          polygons.push(pointsToString(points, origin));
         });
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: VirtualAreaEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          num: data.length,
-          modes,
-          polygons,
-          names,
-          mapId: 0
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualAreaEnum.set,
+          message: {
+            polygons,
+            num: data.length,
+            modes: modes,
+            names: names
+          }
         });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set virtual area');
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualAreaEnum.query, params.message.taskId);
       }
+      const command = encodeVirtualArea0x1a({
+        version: commandVersion,
+        origin,
+        virtualAreas: data
+      });
+      devices.common.model.actions.command_trans.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useVirtualWall.d.ts

@@ -1,23 +1,20 @@
-import { BaseResponse, VirtualWallEnum } from './type';
 import { Point } from '@ray-js/robot-protocol';
-interface VirtualWallResponse extends BaseResponse {
-    reqType: VirtualWallEnum.query;
+type Response = {
     modes: number[];
+    success: boolean;
+    errCode: number;
     num: number;
+    reqType: 'virtualWallQry';
     mapId: number;
+    version: string;
+    taskId: string;
     points: string[];
-}
-interface SetVirtualWallParams {
+};
+type TRequestVirtualWall = () => Promise<Response>;
+type TSetVirtualWall = (params: {
     data: Point[][];
     origin: Point;
-}
-type TRequestVirtualWall = () => Promise<VirtualWallResponse>;
-type TSetVirtualWall = (params: SetVirtualWallParams) => Promise<VirtualWallResponse>;
-/**
- * 自定义 Hook，用于虚拟墙管理
- * @param devId 设备ID
- * @returns 包含 requestVirtualWall 和 setVirtualWall 函数的对象
- */
+}) => Promise<Response> | Promise<void>;
 export declare const useVirtualWall: (devId: string) => {
     requestVirtualWall: TRequestVirtualWall;
     setVirtualWall: TSetVirtualWall;

package/lib/mqtt/useVirtualWall.js

@@ -1,5 +1,6 @@
 import "core-js/modules/esnext.iterator.map.js";
 // 虚拟墙数据
+
 import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
 import { normalResolve } from './promise';
@@ -7,20 +8,6 @@ import { VirtualWallEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeVirtualWall0x12, requestVirtualWall0x13 } from '@ray-js/robot-protocol';
 import { pointsToString } from '../utils';
-
-// 虚拟墙响应类型
-
-// 设置虚拟墙参数类型
-
-// 请求虚拟墙函数类型定义
-
-// 设置虚拟墙函数类型定义
-
-/**
- * 自定义 Hook，用于虚拟墙管理
- * @param devId 设备ID
- * @returns 包含 requestVirtualWall 和 setVirtualWall 函数的对象
- */
 export const useVirtualWall = devId => {
   const {
     useMqtt,
@@ -28,106 +15,56 @@ export const useVirtualWall = devId => {
     devices
   } = useContext(SingletonContext);
 
-  /**
-   * 请求虚拟墙数据
-   * @returns Promise<VirtualWallResponse> 响应结果
-   */
+  // 请求虚拟墙数据
 
   /**
    * 设置虚拟墙数据
-   * @param params 包含虚拟墙设置参数的对象
-   * @param params.data 虚拟墙的点数组
-   * @param params.origin 原点坐标
-   * @returns Promise<VirtualWallResponse> 响应结果
+   * @param message 包含虚拟墙设置参数的对象
+   * @param message.points 虚拟墙的点数组
+   * @param message.num 虚拟墙的数量（可选）
+   * @param message.mode 虚拟墙的模式数组（可选）
+   * @returns Promise<Response> 响应结果
    */
 
   return {
     requestVirtualWall: () => {
-      try {
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: VirtualWallEnum.query
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(VirtualWallEnum.query, taskId);
-        }
-
-        // 非 MQTT 模式：使用命令传输
-        devices.common.model.actions.command_trans.set(requestVirtualWall0x13({
-          version: commandVersion
-        }));
-
-        // 非 MQTT 模式下无法立即获取响应数据，返回默认响应
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: VirtualWallEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          num: 0,
-          modes: [],
-          points: [],
-          mapId: 0
+      if (useMqtt) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualWallEnum.query
         });
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request virtual wall'));
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualWallEnum.query, params.message.taskId);
       }
+      return devices.common.model.actions.command_trans.set(requestVirtualWall0x13({
+        version: commandVersion
+      }));
     },
     setVirtualWall: _ref => {
       let {
         data,
         origin
       } = _ref;
-      // 参数验证
-      if (!Array.isArray(data) || data.length === 0) {
-        throw new Error('data is required and must be a non-empty array');
-      }
-      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 params = createSetCommonParams({
-            deviceId: devId,
-            reqType: VirtualWallEnum.set,
-            message: {
-              points: data.map(points => pointsToString(points, origin)),
-              num: data.length,
-              mode: new Array(data.length).fill('0')
-            }
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(VirtualWallEnum.query, taskId);
-        }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodeVirtualWall0x12({
-          version: commandVersion,
-          origin,
-          walls: data
-        });
-        devices.common.model.actions.command_trans.set(command);
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: VirtualWallEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          num: data.length,
-          modes: new Array(data.length).fill(0),
-          points: data.map(points => pointsToString(points, origin)),
-          mapId: 0
+      if (useMqtt) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualWallEnum.set,
+          message: {
+            points: data.map(points => pointsToString(points, origin)),
+            num: data.length,
+            mode: new Array(data.length).fill('0')
+          }
         });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set virtual wall');
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualWallEnum.query, params.message.taskId);
       }
+      const command = encodeVirtualWall0x12({
+        version: commandVersion,
+        origin,
+        walls: data
+      });
+      devices.common.model.actions.command_trans.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useVoice.d.ts

@@ -1,9 +1,12 @@
-import { BaseResponse, VoiceLanguageEnum } from './type';
-interface VoiceLanguageResponse extends BaseResponse {
-    reqType: VoiceLanguageEnum.query;
+interface VoiceLanguageResponse {
+    reqType: string;
+    version: string;
     id: number;
     schedule: number;
     status: number;
+    success: boolean;
+    errCode: number;
+    taskId: string;
 }
 type TSetVoice = (message: {
     id: number;

package/lib/mqtt/useVoice.js

@@ -7,8 +7,6 @@ import { useContext } from 'react';
 import { SingletonContext } from './mqttProvider';
 import { encodeVoice0x34 } from '@ray-js/robot-protocol';
 
-// 语音语言响应类型
-
 // 设置语音语言函数类型定义
 
 // 请求当前使用的机器语音
@@ -21,100 +19,62 @@ import { encodeVoice0x34 } from '@ray-js/robot-protocol';
 export const useVoice = devId => {
   const {
     useMqtt,
-    devices,
-    commandVersion
+    devices
   } = useContext(SingletonContext);
   /**
    * 请求所有语音语言
-   * @returns Promise<ty.GetVoiceListResponse> 响应结果
+   * @returns Promise<any> 响应结果
    */
 
   /**
    * 请求当前使用的语音语言
-   * @returns Promise<VoiceLanguageResponse> 响应结果
+   * @returns Promise<any> 响应结果
    */
 
   /**
    * 设置语音语言
    * @param message 包含语音语言设置参数的对象
-   * @returns Promise<VoiceLanguageResponse> 响应结果
+   * @returns Promise<Response> 响应结果
    */
 
   return {
     requestAllVoices: async () => {
-      try {
-        const res = await getVoiceList({
-          devId: devId,
-          offset: 0,
-          limit: 100
-        });
-        return res;
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to request all voices');
-      }
+      const res = await getVoiceList({
+        devId: devId,
+        offset: 0,
+        limit: 100
+      });
+      return res;
     },
     requestVoiceInUse: () => {
-      if (!useMqtt) {
-        return Promise.reject(new Error('useMqtt is not used'));
-      }
-      try {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: VoiceLanguageEnum.query
+      });
+      const {
+        taskId
+      } = params.message;
+      ty.device.sendMqttMessage(params);
+      return normalResolve(VoiceLanguageEnum.query, taskId);
+    },
+    setVoice: message => {
+      if (useMqtt) {
+        const sendData = _objectSpread(_objectSpread({}, message), {}, {
+          urlLen: message.url.length
+        });
         const params = createSetCommonParams({
           deviceId: devId,
-          reqType: VoiceLanguageEnum.query
+          reqType: VoiceLanguageEnum.set,
+          message: sendData
         });
-        const {
-          taskId
-        } = params.message;
         ty.device.sendMqttMessage(params);
-        return normalResolve(VoiceLanguageEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request voice in use'));
-      }
-    },
-    setVoice: message => {
-      // 参数验证
-      if (!message || typeof message.id !== 'number') {
-        throw new Error('message.id is required and must be a number');
-      }
-      if (!message.url || typeof message.url !== 'string') {
-        throw new Error('message.url is required and must be a string');
-      }
-      if (!message.md5 || typeof message.md5 !== 'string') {
-        throw new Error('message.md5 is required and must be a string');
-      }
-      try {
-        if (useMqtt) {
-          const sendData = _objectSpread(_objectSpread({}, message), {}, {
-            urlLen: message.url.length
-          });
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: VoiceLanguageEnum.set,
-            message: sendData
-          });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(VoiceLanguageEnum.query, taskId);
-        }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodeVoice0x34(message);
-        devices.common.model.actions.voice_data.set(command);
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: VoiceLanguageEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          id: message.id,
-          schedule: 0,
-          status: 0
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set voice');
+        return normalResolve(VoiceLanguageEnum.query, params.message.taskId);
       }
+      const command = encodeVoice0x34(message);
+      devices.common.model.actions.voice_data.set(command);
+      return Promise.resolve({
+        success: true
+      });
     }
   };
 };

package/lib/mqtt/useWifiMap.js

@@ -8,46 +8,30 @@ export const useWifiMap = devId => {
     useMqtt
   } = useContext(SingletonContext);
 
-  // 请求 WiFi 地图状态
+  // 请求密码状态
 
-  // 设置 WiFi 地图
+  // 设置密码
 
   return {
     requestWifiMap: () => {
-      if (!useMqtt) {
-        return Promise.reject(new Error('useMqtt is not used'));
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: WifiMapEnum.query
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(WifiMapEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request WiFi map'));
-      }
+      if (!useMqtt) return Promise.reject(new Error('useMqtt is not used'));
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: WifiMapEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(WifiMapEnum.query, params.message.taskId);
     },
     setWifiMap: () => {
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: WifiMapEnum.set,
-          message: {
-            taskId: String(Date.now())
-          }
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(WifiMapEnum.rst, taskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set WiFi map');
-      }
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: WifiMapEnum.set,
+        message: {
+          taskId: String(Date.now())
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(WifiMapEnum.rst, params.message.taskId);
     }
   };
 };

package/lib/mqtt/useZoneClean.d.ts

@@ -1,28 +1,28 @@
-import { BaseResponse, ZoneCleanEnum, RoomPreference } from './type';
+import { RoomPreference } from './type';
 import { Point, Zone } from '@ray-js/robot-protocol';
-interface ZoneCleanResponse extends BaseResponse {
-    reqType: ZoneCleanEnum.query;
+type Response = {
+    reqType: string;
+    version: string;
+    success: boolean;
+    errCode: number;
+    taskId: string;
     polygons: string[];
-    names?: string[];
     suctions?: string[];
     cisterns?: string[];
     cleanCounts?: number[];
     yMops?: number[];
     sweepMopModes?: string[];
-}
-interface SetZoneCleanParams extends Partial<Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes'>> {
+};
+type TSetZoneClean = (message: Partial<Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes'>> & {
     zones: Zone[];
     origin: Point;
-}
-type TRequestZoneClean = () => Promise<ZoneCleanResponse>;
-type TSetZoneClean = (params: SetZoneCleanParams) => Promise<ZoneCleanResponse>;
+}) => Promise<Response | void>;
 /**
- * 自定义 Hook，用于划区清扫
- * @param devId 设备ID
- * @returns 包含 requestZoneClean 和 setZoneClean 函数的对象
+ * 划区清扫
+ * @returns
  */
 export declare const useZoneClean: (devId: string) => {
-    requestZoneClean: TRequestZoneClean;
+    requestZoneClean: () => Promise<Response>;
     setZoneClean: TSetZoneClean;
 };
 export {};