@ray-js/robot-data-stream 0.0.10-beta-11 → 0.0.10-beta-12

package/lib/mqtt/usePartMerge.d.ts

@@ -0,0 +1,11 @@
+import { PromiseWithRejection } from './promise';
+type TSetPartMerge = (ids: number[]) => PromiseWithRejection;
+/**
+ * 自定义 Hook，用于分区合并
+ * @param devId 设备ID
+ * @returns 包含 setPartMerge 函数的对象
+ */
+export declare const usePartMerge: (devId: string) => {
+    setPartMerge: TSetPartMerge;
+};
+export {};

package/lib/mqtt/usePartMerge.js

@@ -0,0 +1,33 @@
+// 分区合并
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { PartMergeEnum } from './type';
+
+// 设置分区合并函数类型定义
+
+/**
+ * 自定义 Hook，用于分区合并
+ * @param devId 设备ID
+ * @returns 包含 setPartMerge 函数的对象
+ */
+export const usePartMerge = devId => {
+  /**
+   * 设置分区合并
+   * @param ids 要合并的分区ID数组
+   * @returns Promise<Response> 响应结果
+   */
+
+  return {
+    setPartMerge: ids => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PartMergeEnum.set,
+        message: {
+          ids
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PartMergeEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/usePassword.d.ts

@@ -0,0 +1,17 @@
+import { PromiseWithRejection } from './promise';
+type TRequestPassword = () => PromiseWithRejection;
+type TSetPassword = (params: {
+    password: string;
+    oldPassword?: string;
+    taskId?: string;
+}) => PromiseWithRejection;
+type TCheckPassword = (params: {
+    password: string;
+    taskId?: string;
+}) => PromiseWithRejection;
+export declare const usePassword: (devId: string) => {
+    requestPassword: TRequestPassword;
+    setPassword: TSetPassword;
+    checkPassword: TCheckPassword;
+};
+export {};

package/lib/mqtt/usePassword.js

@@ -0,0 +1,56 @@
+import md5 from 'crypto-js/md5';
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { PasswordEnum } from './type';
+export const usePassword = devId => {
+  // 请求密码状态
+
+  // 设置密码
+
+  // 校验密码
+
+  return {
+    requestPassword: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PasswordEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PasswordEnum.query, params.message.taskId);
+    },
+    setPassword: _ref => {
+      let {
+        password,
+        oldPassword,
+        taskId
+      } = _ref;
+      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
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PasswordEnum.rst, params.message.taskId);
+    },
+    checkPassword: _ref2 => {
+      let {
+        password,
+        taskId
+      } = _ref2;
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PasswordEnum.check,
+        message: {
+          taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
+          password: md5(password).toString()
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PasswordEnum.checkRst, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useQuiteHours.d.ts

@@ -0,0 +1,24 @@
+import { PromiseWithRejection } from './promise';
+type TSetQuiteHours = (params: {
+    startTime: {
+        hour: number;
+        minute: number;
+    };
+    endTime: {
+        hour: number;
+        minute: number;
+    };
+    active: number;
+    day: number;
+    version?: string;
+}) => PromiseWithRejection;
+/**
+ * 自定义 Hook，用于勿扰模式
+ * @param devId 设备ID
+ * @returns 包含 setQuiteHours 和 requestQuiteHours 函数的对象
+ */
+export declare const useQuiteHours: (devId: string) => {
+    setQuiteHours: TSetQuiteHours;
+    requestQuiteHours: () => PromiseWithRejection;
+};
+export {};

package/lib/mqtt/useQuiteHours.js

@@ -0,0 +1,71 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+const _excluded = ["startTime", "endTime"];
+// 勿扰模式
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { QuietHoursEnum } from './type';
+
+// 设置勿扰模式函数类型定义
+
+/**
+ * 自定义 Hook，用于勿扰模式
+ * @param devId 设备ID
+ * @returns 包含 setQuiteHours 和 requestQuiteHours 函数的对象
+ */
+export const useQuiteHours = devId => {
+  /**
+   * 请求勿扰模式数据
+   * @returns Promise<{ time: string[]; day: number; active: number }> 响应结果
+   */
+
+  /**
+   * 设置勿扰模式
+   * @param message 包含勿扰模式设置参数的对象
+   * @returns Promise<Response> 响应结果
+   */
+
+  return {
+    setQuiteHours: message => {
+      const {
+          startTime,
+          endTime
+        } = message,
+        others = _objectWithoutProperties(message, _excluded);
+      if (!startTime || !endTime) {
+        throw new Error('Invalid time');
+      }
+      const {
+        hour: h0,
+        minute: m0
+      } = startTime;
+      const {
+        hour: h1,
+        minute: m1
+      } = endTime;
+      if (h0 > 23 || h0 < 0 || h1 > 23 || h1 < 0 || m0 > 59 || m0 < 0 || m1 > 59 || m1 < 0) {
+        throw new Error('Invalid time');
+      }
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: QuietHoursEnum.set,
+        message: _objectSpread({
+          time: [`${h0},${m0}`, `${h1},${m1}`]
+        }, others)
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(QuietHoursEnum.query, params.message.taskId);
+    },
+    requestQuiteHours: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: QuietHoursEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(QuietHoursEnum.query, taskId);
+    }
+  };
+};

package/lib/mqtt/useResetMap.d.ts

@@ -0,0 +1,3 @@
+export declare const useResetMap: (devId: string) => {
+    setResetMap: () => Promise<void>;
+};

package/lib/mqtt/useResetMap.js

@@ -0,0 +1,17 @@
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { ResetCurrMapEnum } from './type';
+export const useResetMap = devId => {
+  // 重置地图
+
+  return {
+    setResetMap: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: ResetCurrMapEnum.set
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(ResetCurrMapEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useRoomProperty.d.ts

@@ -0,0 +1,12 @@
+import { PromiseWithRejection } from './promise';
+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: () => PromiseWithRejection;
+    setRoomProperty: TSetRoomProperty;
+};
+export {};

package/lib/mqtt/useRoomProperty.js

@@ -0,0 +1,66 @@
+import { isArray } from 'lodash-es';
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { RoomPropertyEnum } from './type';
+export const useRoomProperty = devId => {
+  // 请求房间属性
+
+  // 设置房间属性
+
+  return {
+    requestRoomProperty: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomPropertyEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomPropertyEnum.query, params.message.taskId);
+    },
+    setRoomProperty: message => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomPropertyEnum.set,
+        message
+      });
+      const {
+        ids
+      } = message;
+      if (!isArray(ids) || isArray(ids) && ids.length === 0) {
+        return Promise.reject(new Error('ids is required'));
+      }
+      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)) {
+        // 设置超时定时器
+        return Promise.reject(new Error('cisterns is illegal'));
+      }
+      if (cisterns && !isArray(cisterns)) {
+        return Promise.reject(new Error('cisterns is illegal'));
+      }
+      if (cleanCounts && !isArray(cleanCounts)) {
+        return Promise.reject(new Error('cleanCounts is illegal'));
+      }
+      if (yMops && !isArray(yMops)) {
+        return Promise.reject(new Error('yMops is illegal'));
+      }
+      if (sweepMopModes && !isArray(sweepMopModes)) {
+        return Promise.reject(new Error('sweepMopModes is illegal'));
+      }
+      if (names && !isArray(names)) {
+        return Promise.reject(new Error('names is illegal'));
+      }
+      if (len !== suctions.length || len !== cisterns.length || len !== cleanCounts.length || len !== yMops.length || len !== sweepMopModes.length || len !== names.length) {
+        return Promise.reject(new Error('The length of the parameters is inconsistent'));
+      }
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomPropertyEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useSchedule.d.ts

@@ -0,0 +1,16 @@
+import { PromiseWithRejection } from './promise';
+import { RoomPreference } 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;
+}
+export declare const useSchedule: (devId: string) => {
+    requestSchedule: () => PromiseWithRejection;
+    setSchedule: (message: Schedule) => PromiseWithRejection;
+};
+export {};

package/lib/mqtt/useSchedule.js

@@ -0,0 +1,38 @@
+// 定时
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { ScheduleEnum } from './type';
+
+// 定时任务
+
+export const useSchedule = devId => {
+  // 请求定时数据
+
+  // 下发定时数据
+
+  return {
+    requestSchedule: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: ScheduleEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(ScheduleEnum.query, taskId);
+    },
+    setSchedule: message => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: ScheduleEnum.set,
+        message
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(ScheduleEnum.query, taskId);
+    }
+  };
+};

package/lib/mqtt/useSelectRoomClean.d.ts

@@ -0,0 +1,11 @@
+export declare const useSelectRoomClean: (devId: string) => {
+    requestSelectRoomClean: () => import("./promise").PromiseWithRejection;
+    setRoomClean: (message: {
+        ids: number[];
+        suctions?: string[] | undefined;
+        cisterns?: string[] | undefined;
+        cleanCounts?: number[] | undefined;
+        yMops?: number[] | undefined;
+        sweepMopModes?: string[] | undefined;
+    }) => Promise<never> | import("./promise").PromiseWithRejection;
+};

package/lib/mqtt/useSelectRoomClean.js

@@ -0,0 +1,70 @@
+// 选区清扫
+import { isArray } from 'lodash-es';
+import { createSetCommonParams } from './createCommonOptions';
+import { RoomCleanSetEnum } from './type';
+import { normalResolve } from './promise';
+export const useSelectRoomClean = devId => {
+  // 请求选区清扫信息
+
+  // 设置选区清扫
+  // 选区清扫的清扫属性，当全局模式下使用全局的清扫属性，当自定义模式下，使用房间自定义的清扫属性
+
+  return {
+    requestSelectRoomClean: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomCleanSetEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomCleanSetEnum.query, params.message.taskId);
+    },
+    setRoomClean: message => {
+      const {
+        ids
+      } = message;
+      if (!isArray(ids) || isArray(ids) && ids.length === 0) {
+        return Promise.reject(new Error('ids is required'));
+      }
+      const num = ids.length;
+      const {
+        suctions = new Array(num).fill(''),
+        cisterns = new Array(num).fill(''),
+        cleanCounts = new Array(num).fill(1),
+        yMops = new Array(num).fill(-1),
+        sweepMopModes = new Array(num).fill('only_sweep')
+      } = message;
+      if (suctions && !isArray(suctions)) {
+        return Promise.reject(new Error('suctions is illegal'));
+      }
+      if (cisterns && !isArray(cisterns)) {
+        return Promise.reject(new Error('cisterns is illegal'));
+      }
+      if (cleanCounts && !isArray(cleanCounts)) {
+        return Promise.reject(new Error('cleanCounts is illegal'));
+      }
+      if (yMops && !isArray(yMops)) {
+        return Promise.reject(new Error('yMops is illegal'));
+      }
+      if (sweepMopModes && !isArray(sweepMopModes)) {
+        return Promise.reject(new Error('sweepMopModes is illegal'));
+      }
+      if (num !== suctions.length || num !== cisterns.length || num !== cleanCounts.length || num !== yMops.length || num !== sweepMopModes.length) {
+        return Promise.reject(new Error('The length of the parameters is inconsistent'));
+      }
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomCleanSetEnum.set,
+        message: {
+          ids,
+          suctions,
+          cisterns,
+          cleanCounts,
+          yMops,
+          sweepMopModes
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomCleanSetEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useSpotClean.d.ts

@@ -0,0 +1,14 @@
+import { RoomPreference } from './type';
+type TSetSpotClean = (message: Partial<Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes'>> & {
+    polygons: string[];
+    names?: string[];
+}) => Promise<void>;
+/**
+ * 定点清扫
+ * @returns
+ */
+export declare const useSpotClean: (devId: string) => {
+    requestSpotClean: () => Promise<void>;
+    setSpotClean: TSetSpotClean;
+};
+export {};

package/lib/mqtt/useSpotClean.js

@@ -0,0 +1,81 @@
+// 定点清扫
+
+import { isArray } from 'lodash-es';
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { SpotCleanEnum } from './type';
+/**
+ * 定点清扫
+ * @returns
+ */
+export const useSpotClean = devId => {
+  // 请求定点清扫数据
+
+  // 设置定点清扫
+  // 定点清扫的清扫属性，使用全局的清扫属性
+
+  return {
+    requestSpotClean: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: SpotCleanEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(SpotCleanEnum.query, params.message.taskId);
+    },
+    setSpotClean: message => {
+      const {
+        polygons
+      } = message;
+      if (!isArray(polygons) || isArray(polygons) && polygons.length === 0) {
+        return Promise.reject(new Error('message is required'));
+      }
+      const num = polygons.length;
+      const {
+        suctions = new Array(num).fill(''),
+        cisterns = new Array(num).fill(''),
+        cleanCounts = new Array(num).fill(1),
+        yMops = new Array(num).fill(-1),
+        sweepMopModes = new Array(num).fill('only_sweep'),
+        names = new Array(num).fill('')
+      } = message;
+      if (suctions && !isArray(suctions)) {
+        return Promise.reject(new Error('suctions is illegal'));
+      }
+      if (cisterns && !isArray(cisterns)) {
+        return Promise.reject(new Error('cisterns is illegal'));
+      }
+      if (cleanCounts && !isArray(cleanCounts)) {
+        return Promise.reject(new Error('cleanCounts is illegal'));
+      }
+      if (yMops && !isArray(yMops)) {
+        return Promise.reject(new Error('yMops is illegal'));
+      }
+      if (sweepMopModes && !isArray(sweepMopModes)) {
+        return Promise.reject(new Error('sweepMopModes is illegal'));
+      }
+      if (names && !isArray(names)) {
+        return Promise.reject(new Error('names is illegal'));
+      }
+      if (num !== suctions.length || num !== cisterns.length || num !== cleanCounts.length || num !== yMops.length || num !== sweepMopModes.length || num !== names.length) {
+        return Promise.reject(new Error('The length of the parameters is inconsistent'));
+      }
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: SpotCleanEnum.set,
+        message: {
+          num,
+          polygons,
+          suctions,
+          cisterns,
+          cleanCounts,
+          yMops,
+          sweepMopModes,
+          names
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(SpotCleanEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useVirtualArea.d.ts

@@ -0,0 +1,4 @@
+export declare const useVirtualArea: (devId: string) => {
+    requestVirtualArea: () => any;
+    setVirtualArea: (message: any) => any;
+};

package/lib/mqtt/useVirtualArea.js

@@ -0,0 +1,29 @@
+// 添加禁区
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { VirtualAreaEnum } from './type';
+// 禁区
+
+export const useVirtualArea = devId => {
+  // 请求禁区数据
+
+  return {
+    requestVirtualArea: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: VirtualAreaEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(VirtualAreaEnum.query, params.message.taskId);
+    },
+    setVirtualArea: message => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: VirtualAreaEnum.set,
+        message
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(VirtualAreaEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useVirtualWall.d.ts

@@ -0,0 +1,4 @@
+export declare const useVirtualWall: (devId: string) => {
+    requestVirtualWall: () => import("./promise").PromiseWithRejection;
+    setVirtualWall: (message: any) => import("./promise").PromiseWithRejection;
+};

package/lib/mqtt/useVirtualWall.js

@@ -0,0 +1,36 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+// 虚拟墙数据
+
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { VirtualWallEnum } from './type';
+export const useVirtualWall = devId => {
+  // 请求虚拟墙数据
+
+  /**
+   *  设置虚拟墙数据
+   * @param message 下发给设备的数据
+   * @param isVerify
+   */
+
+  return {
+    requestVirtualWall: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: VirtualWallEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(VirtualWallEnum.query, params.message.taskId);
+    },
+    setVirtualWall: message => {
+      const requestParams = _objectSpread({}, message);
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: VirtualWallEnum.set,
+        message: requestParams
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(VirtualWallEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useVoice.d.ts

@@ -0,0 +1,18 @@
+import { PromiseWithRejection } from './promise';
+type TSetVoice = (message: {
+    id: number;
+    url: string;
+    md5: string;
+}) => PromiseWithRejection;
+type TRequestVoiceInUse = () => PromiseWithRejection;
+/**
+ * 自定义 Hook，用于语音语言设置
+ * @param devId 设备ID
+ * @returns 包含 requestAllVoices, requestVoiceInUse 和 setVoice 函数的对象
+ */
+export declare const useVoice: (devId: string) => {
+    requestAllVoices: () => Promise<ty.GetVoiceListResponse>;
+    requestVoiceInUse: TRequestVoiceInUse;
+    setVoice: TSetVoice;
+};
+export {};