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

package/lib/mqtt/usePartDivision.js

@@ -1,86 +1,77 @@
 // 房间分隔
+import { encodePartitionDivision0x1c } from '@ray-js/robot-protocol';
 import { useContext } from 'react';
 import { pointsToString } from '../utils';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
-import { PartDivisionEnum } from './type';
+import { handleMqttError, useStructuredMessage } from './hooks/useStructuredMessage';
 import { SingletonContext } from './mqttProvider';
-import { encodePartitionDivision0x1c } from '@ray-js/robot-protocol';
-
-// 房间分隔响应类型
-
-// 设置房间分隔函数类型定义
-
+import { PartDivisionEnum } from './type';
+import { validator } from './type/fun';
 /**
  * 自定义 Hook，用于房间分隔
- * @param devId 设备ID
  * @returns 包含 setPartDivision 函数的对象
  */
-export const usePartDivision = devId => {
+export const usePartDivision = () => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
 
   /**
    * 设置房间分隔
-   * @param points 分隔点数组，SDK方法抛出来的坐标直接传入即可
-   * @param roomId 房间ID，当前要分隔的房间
+   * @param points 分隔点数组
+   * @param roomId 房间ID，当前要分隔的房间（可以是 int 或 string）
    * @param origin 地图原点坐标
    * @returns Promise<PartDivisionResponse> 响应结果
    */
 
   return {
     setPartDivision: (points, roomId, origin) => {
-      // 参数验证
-      if (!Array.isArray(points) || points.length === 0) {
-        throw new Error('points is required and must be a non-empty array');
-      }
-      if (typeof roomId !== 'number' || isNaN(roomId)) {
-        throw new Error('roomId is required and must be a valid number');
-      }
-      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 pointStr = pointsToString(points, origin);
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: PartDivisionEnum.set,
-            message: {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用验证器验证三个独立参数
+          const validatedData = validator.validateSetPartDivision(points, roomId, origin);
+          const {
+            points: validatedPoints,
+            roomId: validatedRoomId,
+            origin: validatedOrigin
+          } = validatedData;
+          if (useMqtt) {
+            // 将点数组转换为字符串格式
+            const pointStr = pointsToString(validatedPoints, validatedOrigin);
+            sendStructuredMessage(PartDivisionEnum.set, {
               lines: [pointStr],
               // 分隔线数组
-              ids: [roomId] // 房间ID数组
-            }
+              ids: [validatedRoomId] // 房间ID数组
+            }, resolve, error => reject(handleMqttError(error, 'Failed to set part division')), PartDivisionEnum.query // 响应类型是 query，不是 set
+            );
+            return;
+          }
+
+          // 非 MQTT 模式：使用命令传输
+          // 将 roomId 转换为数字（如果它是字符串）
+          const roomIdNumber = typeof validatedRoomId === 'string' ? Number(validatedRoomId) : validatedRoomId;
+          const command = encodePartitionDivision0x1c({
+            version: commandVersion,
+            origin: validatedOrigin,
+            points: validatedPoints,
+            roomId: roomIdNumber
           });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(PartDivisionEnum.query, taskId);
+          devices.common.model.actions.command_trans.set(command);
+          resolve({
+            success: true,
+            errCode: 0,
+            reqType: PartDivisionEnum.query,
+            version: commandVersion,
+            taskId: `${Date.now()}`
+          });
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set part division'));
         }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodePartitionDivision0x1c({
-          version: commandVersion,
-          origin,
-          points,
-          roomId
-        });
-        devices.common.model.actions.command_trans.set(command);
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: PartDivisionEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set part division');
-      }
+      });
     }
   };
 };

package/lib/mqtt/usePartMerge.d.ts

@@ -1,14 +1,8 @@
-import { BaseResponse, PartMergeEnum } from './type';
-interface PartMergeResponse extends BaseResponse {
-    reqType: PartMergeEnum.query;
-}
-type TSetPartMerge = (ids: number[]) => Promise<PartMergeResponse>;
+import { type TSetPartMerge } from './type/protocols';
 /**
  * 自定义 Hook，用于分区合并
- * @param devId 设备ID
  * @returns 包含 setPartMerge 函数的对象
  */
-export declare const usePartMerge: (devId: string) => {
+export declare const usePartMerge: () => {
     setPartMerge: TSetPartMerge;
 };
-export {};

package/lib/mqtt/usePartMerge.js

@@ -1,75 +1,60 @@
-import "core-js/modules/esnext.iterator.constructor.js";
-import "core-js/modules/esnext.iterator.some.js";
 // 分区合并
 import { useContext } from 'react';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
 import { PartMergeEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodePartitionMerge0x1e } from '@ray-js/robot-protocol';
-
-// 分区合并响应类型
-
-// 设置分区合并函数类型定义
-
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
 /**
  * 自定义 Hook，用于分区合并
- * @param devId 设备ID
  * @returns 包含 setPartMerge 函数的对象
  */
-export const usePartMerge = devId => {
+export const usePartMerge = () => {
   const {
     useMqtt,
     devices,
     commandVersion
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
   /**
    * 设置分区合并
-   * @param ids 要合并的分区ID数组
+   * @param data 包含要合并的分区ID数组的对象
    * @returns Promise<PartMergeResponse> 响应结果
    */
 
   return {
-    setPartMerge: ids => {
-      // 参数验证
-      if (!ids || ids.length < 2) {
-        throw new Error('ids is required and length must be greater than 1');
-      }
-      if (ids.some(id => typeof id !== 'number')) {
-        throw new Error('ids must be an array of numbers');
-      }
-      try {
-        if (useMqtt) {
-          const params = createSetCommonParams({
-            deviceId: devId,
-            reqType: PartMergeEnum.set,
-            message: {
+    setPartMerge: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const ids = validator.validate('set_part_merge', data);
+          if (useMqtt) {
+            sendStructuredMessage(PartMergeEnum.set, {
               ids
-            }
+            }, resolve, error => reject(handleMqttError(error, 'Failed to set part merge')), PartMergeEnum.query // 响应类型是 query，不是 set
+            );
+            return;
+          }
+
+          // 非 MQTT 模式：使用命令传输
+          const command = encodePartitionMerge0x1e({
+            version: commandVersion,
+            roomIds: ids
+          });
+          devices.common.model.actions.command_trans.set(command);
+          resolve({
+            success: true,
+            errCode: 0,
+            reqType: PartMergeEnum.query,
+            version: commandVersion,
+            taskId: `${Date.now()}`
           });
-          ty.device.sendMqttMessage(params);
-          const {
-            taskId
-          } = params.message;
-          return normalResolve(PartMergeEnum.query, taskId);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set part merge'));
         }
-
-        // 非 MQTT 模式：使用命令传输
-        const command = encodePartitionMerge0x1e({
-          version: commandVersion,
-          roomIds: ids
-        });
-        devices.common.model.actions.command_trans.set(command);
-        return Promise.resolve({
-          success: true,
-          errCode: 0,
-          reqType: PartMergeEnum.query,
-          version: commandVersion,
-          taskId: `${Date.now()}`
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set part merge');
-      }
+      });
     }
   };
 };

package/lib/mqtt/usePassword.d.ts

@@ -1,17 +1,10 @@
-import { PromiseWithRejection } from './promise';
-type TRequestPassword = () => PromiseWithRejection | Promise<void>;
-type TSetPassword = (params: {
-    password: string;
-    oldPassword?: string;
-    taskId?: string;
-}) => PromiseWithRejection;
-type TCheckPassword = (params: {
-    password: string;
-    taskId?: string;
-}) => PromiseWithRejection;
-export declare const usePassword: (devId: string) => {
+import { type TRequestPassword, type TSetPassword, type TCheckPassword } from './type/protocols';
+/**
+ * 自定义 Hook，用于密码管理
+ * @returns 包含 requestPassword、setPassword 和 checkPassword 函数的对象
+ */
+export declare const usePassword: () => {
     requestPassword: TRequestPassword;
     setPassword: TSetPassword;
     checkPassword: TCheckPassword;
 };
-export {};

package/lib/mqtt/usePassword.js

@@ -1,94 +1,104 @@
 import md5 from 'crypto-js/md5';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
 import { PasswordEnum } from './type';
 import { useContext } from 'react';
 import { SingletonContext } from './mqttProvider';
-export const usePassword = devId => {
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
+/**
+ * 自定义 Hook，用于密码管理
+ * @returns 包含 requestPassword、setPassword 和 checkPassword 函数的对象
+ */
+export const usePassword = () => {
   const {
     useMqtt
   } = useContext(SingletonContext);
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
 
-  // 请求密码状态
+  /**
+   * 请求密码状态
+   * @returns Promise<PasswordResponse> 响应结果
+   */
 
-  // 设置密码
+  /**
+   * 设置密码
+   * @param params 包含密码设置参数的对象（密码会自动进行 MD5 加密）
+   * @returns Promise<PasswordResponse> 响应结果
+   */
 
-  // 校验密码
+  /**
+   * 校验密码
+   * @param params 包含密码校验参数的对象（密码会自动进行 MD5 加密）
+   * @returns Promise<PasswordResponse> 响应结果
+   */
 
   return {
     requestPassword: () => {
-      if (!useMqtt) {
-        return Promise.reject(new Error('useMqtt is not used'));
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: PasswordEnum.query
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(PasswordEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request password'));
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          if (!useMqtt) {
+            reject(new Error('useMqtt is not used'));
+            return;
+          }
+
+          // request_password 不需要参数，直接发送空对象
+          sendStructuredMessage(PasswordEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request password')));
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request password'));
+        }
+      });
     },
-    setPassword: _ref => {
-      let {
-        password,
-        oldPassword,
-        taskId
-      } = _ref;
-      // 参数验证
-      if (!password || typeof password !== 'string') {
-        throw new Error('password is required and must be a string');
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: PasswordEnum.set,
-          message: {
-            taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
-            password: md5(password).toString(),
-            oldPassword: oldPassword ? md5(oldPassword).toString() : undefined
+    setPassword: params => {
+      return new Promise((resolve, reject) => {
+        try {
+          var _params$taskId;
+          // 先验证原始参数（密码是明文）
+          if (!params.password || typeof params.password !== 'string') {
+            reject(new Error('password is required and must be a string'));
+            return;
           }
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId: finalTaskId
-        } = params.message;
-        return normalResolve(PasswordEnum.rst, finalTaskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set password');
-      }
+
+          // 构建符合 Schema 的数据（密码需要 MD5 加密）
+          const passwordData = {
+            password: md5(params.password).toString(),
+            oldPassword: params.oldPassword ? md5(params.oldPassword).toString() : undefined,
+            taskId: (_params$taskId = params.taskId) !== null && _params$taskId !== void 0 ? _params$taskId : String(Date.now())
+          };
+
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_password', passwordData);
+          sendStructuredMessage(PasswordEnum.set, validatedData, resolve, error => reject(handleMqttError(error, 'Failed to set password')), PasswordEnum.rst // 响应类型是 rst，不是 set
+          );
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set password'));
+        }
+      });
     },
-    checkPassword: _ref2 => {
-      let {
-        password,
-        taskId
-      } = _ref2;
-      // 参数验证
-      if (!password || typeof password !== 'string') {
-        throw new Error('password is required and must be a string');
-      }
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: PasswordEnum.check,
-          message: {
-            taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
-            password: md5(password).toString()
+    checkPassword: params => {
+      return new Promise((resolve, reject) => {
+        try {
+          var _params$taskId2;
+          // 先验证原始参数（密码是明文）
+          if (!params.password || typeof params.password !== 'string') {
+            reject(new Error('password is required and must be a string'));
+            return;
           }
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId: finalTaskId
-        } = params.message;
-        return normalResolve(PasswordEnum.checkRst, finalTaskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to check password');
-      }
+
+          // 构建符合 Schema 的数据（密码需要 MD5 加密）
+          const passwordData = {
+            password: md5(params.password).toString(),
+            taskId: (_params$taskId2 = params.taskId) !== null && _params$taskId2 !== void 0 ? _params$taskId2 : String(Date.now())
+          };
+
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('check_password', passwordData);
+          sendStructuredMessage(PasswordEnum.check, validatedData, resolve, error => reject(handleMqttError(error, 'Failed to check password')), PasswordEnum.checkRst // 响应类型是 checkRst，不是 check
+          );
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to check password'));
+        }
+      });
     }
   };
 };

package/lib/mqtt/useQuiteHours.d.ts

@@ -1,42 +1,9 @@
-import { BaseResponse, QuietHoursEnum } from './type';
-interface QuietHoursResponse extends BaseResponse {
-    reqType: QuietHoursEnum.query;
-    /**
-     * 是否激活
-     * 0 表示未激活，1 表示激活
-     */
-    active: number;
-    /**
-     * 时间段数组，每个元素为 "开始时间, 结束时间" 的字符串
-     */
-    time: string[];
-    /**
-     * 星期几，1 表示星期一，2 表示星期二，以此类推
-     */
-    day: number;
-}
-interface SetQuiteHoursParams {
-    startTime: {
-        hour: number;
-        minute: number;
-    };
-    endTime: {
-        hour: number;
-        minute: number;
-    };
-    active: number;
-    day: number;
-    version?: string;
-}
-type TSetQuiteHours = (params: SetQuiteHoursParams) => Promise<QuietHoursResponse>;
-type TRequestQuiteHours = () => Promise<QuietHoursResponse>;
+import { type TRequestQuietHours, type TSetQuietHours } from './type/protocols';
 /**
  * 自定义 Hook，用于勿扰模式
- * @param devId 设备ID
  * @returns 包含 setQuiteHours 和 requestQuiteHours 函数的对象
  */
-export declare const useQuiteHours: (devId: string) => {
-    setQuiteHours: TSetQuiteHours;
-    requestQuiteHours: TRequestQuiteHours;
+export declare const useQuiteHours: () => {
+    setQuiteHours: TSetQuietHours;
+    requestQuiteHours: TRequestQuietHours;
 };
-export {};