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

package/lib/mqtt/useQuiteHours.js

@@ -1,32 +1,26 @@
 // 勿扰模式
+import { encodeDoNotDisturb0x32 } from '@ray-js/robot-protocol';
 import { useContext } from 'react';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
-import { QuietHoursEnum } from './type';
+import { handleMqttError, useStructuredMessage } from './hooks/useStructuredMessage';
 import { SingletonContext } from './mqttProvider';
-import { encodeDoNotDisturb0x32 } from '@ray-js/robot-protocol';
-
-// 勿扰模式响应类型
-
-// 设置勿扰模式参数类型
-
-// 设置勿扰模式函数类型定义
-
-// 请求勿扰模式函数类型定义
-
+import { QuietHoursEnum } from './type';
+import { validator } from './type/fun';
 /**
  * 自定义 Hook，用于勿扰模式
- * @param devId 设备ID
  * @returns 包含 setQuiteHours 和 requestQuiteHours 函数的对象
  */
-export const useQuiteHours = devId => {
+export const useQuiteHours = () => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
   /**
    * 请求勿扰模式数据
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<QuietHoursResponse> 响应结果
    */
 
@@ -38,98 +32,70 @@ export const useQuiteHours = devId => {
 
   return {
     setQuiteHours: params => {
-      const {
-        startTime,
-        endTime,
-        active,
-        day
-      } = params;
-
-      // 参数验证
-      if (!startTime || typeof startTime.hour !== 'number' || typeof startTime.minute !== 'number') {
-        throw new Error('startTime is required and must be an object with hour and minute properties');
-      }
-      if (!endTime || typeof endTime.hour !== 'number' || typeof endTime.minute !== 'number') {
-        throw new Error('endTime is required and must be an object with hour and minute properties');
-      }
-      if (typeof active !== 'number' || active !== 0 && active !== 1) {
-        throw new Error('active is required and must be 0 or 1');
-      }
-      if (typeof day !== 'number') {
-        throw new Error('day is required and must be a number');
-      }
-      const {
-        hour: h0,
-        minute: m0
-      } = startTime;
-      const {
-        hour: h1,
-        minute: m1
-      } = endTime;
-      if (h0 < 0 || h0 > 23 || m0 < 0 || m0 > 59) {
-        throw new Error('startTime is invalid: hour must be 0-23, minute must be 0-59');
-      }
-      if (h1 < 0 || h1 > 23 || m1 < 0 || m1 > 59) {
-        throw new Error('endTime is invalid: hour must be 0-23, minute must be 0-59');
-      }
-      try {
-        if (useMqtt) {
-          const mqttParams = createSetCommonParams({
-            deviceId: devId,
-            reqType: QuietHoursEnum.set,
-            message: {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_quiet_hours', params);
+          const {
+            startTime,
+            endTime,
+            active,
+            day
+          } = validatedData;
+          const {
+            hour: h0,
+            minute: m0
+          } = startTime;
+          const {
+            hour: h1,
+            minute: m1
+          } = endTime;
+          if (useMqtt) {
+            sendStructuredMessage(QuietHoursEnum.set, {
               time: [`${h0},${m0}`, `${h1},${m1}`],
               active,
               day
-            }
+            }, resolve, error => reject(handleMqttError(error, 'Failed to set quiet hours')), QuietHoursEnum.query // 响应类型是 query，不是 set
+            );
+            return;
+          }
+
+          // 非 MQTT 模式：使用命令传输
+          const command = encodeDoNotDisturb0x32({
+            version: commandVersion,
+            startHour: h0,
+            startMinute: m0,
+            endHour: h1,
+            endMinute: m1
           });
-          ty.device.sendMqttMessage(mqttParams);
-          const {
-            taskId
-          } = mqttParams.message;
-          return normalResolve(QuietHoursEnum.query, taskId);
+          devices.common.model.actions.disturb_time_set.set(command);
+          resolve({
+            success: true,
+            errCode: 0,
+            reqType: QuietHoursEnum.query,
+            version: commandVersion,
+            taskId: `${Date.now()}`,
+            active,
+            time: [`${h0},${m0}`, `${h1},${m1}`],
+            day
+          });
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set quiet hours'));
         }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodeDoNotDisturb0x32({
-          version: commandVersion,
-          startHour: h0,
-          startMinute: m0,
-          endHour: h1,
-          endMinute: m1
-        });
-        devices.common.model.actions.disturb_time_set.set(command);
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: QuietHoursEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`,
-          active,
-          time: [`${h0},${m0}`, `${h1},${m1}`],
-          day
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set quiet hours');
-      }
+      });
     },
     requestQuiteHours: () => {
-      if (!useMqtt) {
-        return Promise.reject(new Error('useMqtt is not used'));
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: QuietHoursEnum.query
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(QuietHoursEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request quiet hours'));
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          if (!useMqtt) {
+            reject(new Error('useMqtt is not used'));
+            return;
+          }
+          sendStructuredMessage(QuietHoursEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request quiet hours')));
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request quiet hours'));
+        }
+      });
     }
   };
 };

package/lib/mqtt/useResetMap.d.ts

@@ -1,14 +1,8 @@
-import { BaseResponse, ResetCurrMapEnum } from './type';
-interface ResetMapResponse extends BaseResponse {
-    reqType: ResetCurrMapEnum.query;
-}
-type TSetResetMap = () => Promise<ResetMapResponse>;
+import { type TSetResetMap } from './type/protocols';
 /**
  * 自定义 Hook，用于重置地图
- * @param devId 设备ID
  * @returns 包含 setResetMap 函数的对象
  */
-export declare const useResetMap: (devId: string) => {
+export declare const useResetMap: () => {
     setResetMap: TSetResetMap;
 };
-export {};

package/lib/mqtt/useResetMap.js

@@ -1,60 +1,53 @@
 // 重置地图
 import { useContext } from 'react';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
 import { ResetCurrMapEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeResetMap0x42 } from '@ray-js/robot-protocol';
-
-// 重置地图响应类型
-
-// 设置重置地图函数类型定义
-
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
 /**
  * 自定义 Hook，用于重置地图
- * @param devId 设备ID
  * @returns 包含 setResetMap 函数的对象
  */
-export const useResetMap = devId => {
+export const useResetMap = () => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
   /**
    * 重置地图
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<ResetMapResponse> 响应结果
    */
 
   return {
     setResetMap: () => {
-      try {
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: ResetCurrMapEnum.set
+      return new Promise((resolve, reject) => {
+        try {
+          if (useMqtt) {
+            sendStructuredMessage(ResetCurrMapEnum.set, {}, resolve, error => reject(handleMqttError(error, 'Failed to reset map')), ResetCurrMapEnum.query // 响应类型是 query，不是 set
+            );
+            return;
+          }
+
+          // 非 MQTT 模式：使用命令传输
+          devices.common.model.actions.command_trans.set(encodeResetMap0x42({
+            version: commandVersion
+          }));
+          resolve({
+            success: true,
+            errCode: 0,
+            reqType: ResetCurrMapEnum.query,
+            version: commandVersion,
+            taskId: `${Date.now()}`
           });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(ResetCurrMapEnum.query, taskId);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to reset map'));
         }
-
-        // 非 MQTT 模式：使用命令传输
-        devices.common.model.actions.command_trans.set(encodeResetMap0x42({
-          version: commandVersion
-        }));
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: ResetCurrMapEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to reset map');
-      }
+      });
     }
   };
 };

package/lib/mqtt/useRoomProperty.d.ts

@@ -1,11 +1,10 @@
-import { BaseResponse, RoomPreference } from './type';
-type Response = BaseResponse & RoomPreference & {
-    num: number;
-    mapId: number;
-};
-type TSetRoomProperty = (message: Pick<Response, 'num' | 'suctions' | 'cisterns' | 'floorTypes' | 'names' | 'orders' | 'yMops' | 'sweepMopModes' | 'cleanCounts' | 'ids'>) => Promise<RoomPreference>;
-export declare const useRoomProperty: (devId: string) => {
-    requestRoomProperty: () => Promise<Response>;
+import { type TRequestRoomProperty, type TSetRoomProperty } from './type/protocols/roomPropertyProtocol';
+/**
+ * 自定义 Hook，用于房间属性管理
+ * @param devId 设备ID（可选，如果不提供则从 MqttProvider Context 获取）
+ * @returns 包含 requestRoomProperty 和 setRoomProperty 函数的对象
+ */
+export declare const useRoomProperty: () => {
+    requestRoomProperty: TRequestRoomProperty;
     setRoomProperty: TSetRoomProperty;
 };
-export {};

package/lib/mqtt/useRoomProperty.js

@@ -1,80 +1,82 @@
-import { isArray } from 'lodash-es';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
-import { RoomPropertyEnum } from './type';
 import { useContext } from 'react';
+import { handleMqttError, useStructuredMessage } from './hooks/useStructuredMessage';
 import { SingletonContext } from './mqttProvider';
-export const useRoomProperty = devId => {
+import { RoomPropertyEnum } from './type';
+import { validator } from './type/fun';
+/**
+ * 自定义 Hook，用于房间属性管理
+ * @param devId 设备ID（可选，如果不提供则从 MqttProvider Context 获取）
+ * @returns 包含 requestRoomProperty 和 setRoomProperty 函数的对象
+ */
+export const useRoomProperty = () => {
   const {
     useMqtt
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
 
-  // 请求房间属性
+  /**
+   * 请求房间属性
+   * @param data 可选参数（目前为空对象）
+   * @returns Promise<RoomPropertyResponse> 响应结果
+   */
 
-  // 设置房间属性
+  /**
+   * 设置房间属性
+   * @param data 包含房间属性设置参数的对象
+   * @returns Promise<RoomPropertyResponse> 响应结果
+   */
 
   return {
     requestRoomProperty: () => {
-      if (!useMqtt) return Promise.reject(new Error('useMqtt is not used'));
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: RoomPropertyEnum.query
+      return new Promise((resolve, reject) => {
+        try {
+          if (!useMqtt) {
+            reject(new Error('useMqtt is not used'));
+            return;
+          }
+          sendStructuredMessage(RoomPropertyEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request room property')));
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request room property'));
+        }
       });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(RoomPropertyEnum.query, params.message.taskId);
     },
-    setRoomProperty: message => {
-      // 参数验证
-      const {
-        ids
-      } = message;
-      if (!isArray(ids) || isArray(ids) && ids.length === 0) {
-        throw new Error('ids is required and must be a non-empty array');
-      }
-      const len = ids.length;
-      const {
-        suctions = new Array(len).fill('closed'),
-        cisterns = new Array(len).fill('closed'),
-        cleanCounts = new Array(len).fill(1),
-        yMops = new Array(len).fill(-1),
-        sweepMopModes = new Array(len).fill('only_sweep'),
-        names = new Array(len).fill('')
-      } = message;
-      if (suctions && !isArray(suctions)) {
-        throw new Error('suctions is illegal');
-      }
-      if (cisterns && !isArray(cisterns)) {
-        throw new Error('cisterns is illegal');
-      }
-      if (cleanCounts && !isArray(cleanCounts)) {
-        throw new Error('cleanCounts is illegal');
-      }
-      if (yMops && !isArray(yMops)) {
-        throw new Error('yMops is illegal');
-      }
-      if (sweepMopModes && !isArray(sweepMopModes)) {
-        throw new Error('sweepMopModes is illegal');
-      }
-      if (names && !isArray(names)) {
-        throw new Error('names is illegal');
-      }
-      if (len !== suctions.length || len !== cisterns.length || len !== cleanCounts.length || len !== yMops.length || len !== sweepMopModes.length || len !== names.length) {
-        throw new Error('The length of the parameters is inconsistent');
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: RoomPropertyEnum.set,
-          message
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(RoomPropertyEnum.query, taskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set room property');
-      }
+    setRoomProperty: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          var _data$num, _data$suctions, _data$cisterns, _data$cleanCounts, _data$yMops, _data$sweepMopModes, _data$names;
+          if (!useMqtt) {
+            reject(new Error('useMqtt is not used'));
+            return;
+          }
+
+          // 构建发送数据，为可选字段设置默认值
+          const {
+            ids
+          } = data;
+          const len = ids.length;
+          const sendData = {
+            num: (_data$num = data.num) !== null && _data$num !== void 0 ? _data$num : len,
+            ids,
+            suctions: (_data$suctions = data.suctions) !== null && _data$suctions !== void 0 ? _data$suctions : new Array(len).fill('closed'),
+            cisterns: (_data$cisterns = data.cisterns) !== null && _data$cisterns !== void 0 ? _data$cisterns : new Array(len).fill('closed'),
+            cleanCounts: (_data$cleanCounts = data.cleanCounts) !== null && _data$cleanCounts !== void 0 ? _data$cleanCounts : new Array(len).fill(1),
+            yMops: (_data$yMops = data.yMops) !== null && _data$yMops !== void 0 ? _data$yMops : new Array(len).fill(-1),
+            sweepMopModes: (_data$sweepMopModes = data.sweepMopModes) !== null && _data$sweepMopModes !== void 0 ? _data$sweepMopModes : new Array(len).fill('only_sweep'),
+            names: (_data$names = data.names) !== null && _data$names !== void 0 ? _data$names : new Array(len).fill(''),
+            floorTypes: data.floorTypes,
+            orders: data.orders
+          };
+
+          // 使用 TypeBox Schema 进行参数验证（包含自定义验证逻辑）
+          const validatedData = validator.validate('set_room_property', sendData);
+          sendStructuredMessage(RoomPropertyEnum.set, validatedData, resolve, error => reject(handleMqttError(error, 'Failed to set room property')), RoomPropertyEnum.query // 响应类型是 query，不是 set
+          );
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set room property'));
+        }
+      });
     }
   };
 };

package/lib/mqtt/useSchedule.d.ts

@@ -1,30 +1,10 @@
-import { ScheduleEnum, RoomPreference, BaseResponse } from './type';
-type ScheduleItem = Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes' | 'ids'> & {
-    active: number;
-    cycle: number[];
-    time: number[];
-};
-interface Schedule {
-    list: Array<ScheduleItem>;
-    num: number;
-    version?: string;
-}
-interface ScheduleResponse extends BaseResponse {
-    reqType: ScheduleEnum.query;
-    list: Array<ScheduleItem>;
-    num: number;
-}
-type TRequestSchedule = (message?: {
-    version?: string;
-}) => Promise<ScheduleResponse>;
-type TSetSchedule = (message: Schedule) => Promise<ScheduleResponse>;
+import { type TRequestSchedule, type TSetSchedule } from './type/protocols';
 /**
  * 自定义 Hook，用于定时任务
- * @param devId 设备ID
+ * @param devId 设备ID（可选，如果不提供则从 MqttProvider Context 获取）
  * @returns 包含 requestSchedule 和 setSchedule 函数的对象
  */
-export declare const useSchedule: (devId: string) => {
+export declare const useSchedule: () => {
     requestSchedule: TRequestSchedule;
     setSchedule: TSetSchedule;
 };
-export {};