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

package/lib/constant.d.ts

@@ -1,55 +1,3 @@
 export declare const SUCTION_MAP: Record<string, number>;
 export declare const CISTERN_MAP: Record<string, number>;
 export declare const CLEAN_MODE_MAP: Record<string, number>;
-export declare enum FileNameEnum {
-    map = "map.bin",
-    mapStructured = "map_structured.bin",
-    cleanPath = "cleanPath.bin",
-    mapStream = "map.bin.stream",
-    mapStructuredStream = "map_structured.bin.stream",
-    cleanPathStream = "cleanPath.bin.stream",
-    ai = "ai.bin",
-    aiStream = "ai.bin.stream",
-    aiHD = "aiHD_XXXX_YYYY.bin",
-    aiHDStream = "aiHD_XXXX_YYYY.bin.stream",
-    wifiMap = "wifi_map.bin",
-    wifiMapStream = "wifi_map.bin.stream"
-}
-export declare const FILE_NAME_MAP: {
-    readonly "map.bin": {
-        readonly type: 0;
-    };
-    readonly "map_structured.bin": {
-        readonly type: 6;
-    };
-    readonly "cleanPath.bin": {
-        readonly type: 1;
-    };
-    readonly "map.bin.stream": {
-        readonly type: 0;
-    };
-    readonly "map_structured.bin.stream": {
-        readonly type: 6;
-    };
-    readonly "cleanPath.bin.stream": {
-        readonly type: 1;
-    };
-    readonly "ai.bin": {
-        readonly type: 4;
-    };
-    readonly "ai.bin.stream": {
-        readonly type: 4;
-    };
-    readonly "aiHD_XXXX_YYYY.bin": {
-        readonly type: 5;
-    };
-    readonly "aiHD_XXXX_YYYY.bin.stream": {
-        readonly type: 5;
-    };
-    readonly "wifi_map.bin": {
-        readonly type: 7;
-    };
-    readonly "wifi_map.bin.stream": {
-        readonly type: 7;
-    };
-};

package/lib/constant.js

@@ -1,4 +1,3 @@
-import "core-js/modules/esnext.iterator.map.js";
 // 吸力
 export const SUCTION_MAP = {
   closed: 0,
@@ -27,57 +26,4 @@ export const CLEAN_MODE_MAP = {
   // 先扫后拖
   clean_before_mop: 3,
   sweep_after_mop: 3
-};
-export let FileNameEnum = /*#__PURE__*/function (FileNameEnum) {
-  FileNameEnum["map"] = "map.bin";
-  FileNameEnum["mapStructured"] = "map_structured.bin";
-  FileNameEnum["cleanPath"] = "cleanPath.bin";
-  FileNameEnum["mapStream"] = "map.bin.stream";
-  FileNameEnum["mapStructuredStream"] = "map_structured.bin.stream";
-  FileNameEnum["cleanPathStream"] = "cleanPath.bin.stream";
-  FileNameEnum["ai"] = "ai.bin";
-  FileNameEnum["aiStream"] = "ai.bin.stream";
-  FileNameEnum["aiHD"] = "aiHD_XXXX_YYYY.bin";
-  FileNameEnum["aiHDStream"] = "aiHD_XXXX_YYYY.bin.stream";
-  FileNameEnum["wifiMap"] = "wifi_map.bin";
-  FileNameEnum["wifiMapStream"] = "wifi_map.bin.stream";
-  return FileNameEnum;
-}({});
-export const FILE_NAME_MAP = {
-  [FileNameEnum.map]: {
-    type: 0
-  },
-  [FileNameEnum.mapStructured]: {
-    type: 6
-  },
-  [FileNameEnum.cleanPath]: {
-    type: 1
-  },
-  [FileNameEnum.mapStream]: {
-    type: 0
-  },
-  [FileNameEnum.mapStructuredStream]: {
-    type: 6
-  },
-  [FileNameEnum.cleanPathStream]: {
-    type: 1
-  },
-  [FileNameEnum.ai]: {
-    type: 4
-  },
-  [FileNameEnum.aiStream]: {
-    type: 4
-  },
-  [FileNameEnum.aiHD]: {
-    type: 5
-  },
-  [FileNameEnum.aiHDStream]: {
-    type: 5
-  },
-  [FileNameEnum.wifiMap]: {
-    type: 7
-  },
-  [FileNameEnum.wifiMapStream]: {
-    type: 7
-  }
 };

package/lib/index.d.ts

@@ -1,5 +1,16 @@
-import { useP2PDataStream } from './api';
 export * from './mqtt';
 export * from './mqtt/type/requestType';
+type TOnLogger = (type: 'warn' | 'error' | 'info', data: string) => void;
+declare const useP2PDataStream: (devId: string, onReceiveMapData: (data: string) => void, onReceivePathData: (data: string) => void, opt?: {
+    logTag?: string | undefined;
+    enableCustomLog?: boolean | undefined;
+    onReceiveAIPicData?: ((data: string) => void) | undefined;
+    onReceiveAIPicHDData?: ((data: string) => void) | undefined;
+    onReceiveWifiMapData?: ((data: string) => void) | undefined;
+    onLogger?: TOnLogger | undefined;
+    onDefineStructuredMode?: ((isStructured: boolean) => void) | undefined;
+} | undefined) => {
+    appendDownloadStreamDuringTask: (files: Array<string>, successCb?: () => void, failedCb?: () => void) => Promise<boolean> | void;
+};
 declare const StreamDataNotificationCenter: import("mitt").Emitter<Record<import("mitt").EventType, unknown>>;
 export { StreamDataNotificationCenter, useP2PDataStream };

package/lib/index.js

@@ -1,6 +1,191 @@
-import { useP2PDataStream } from './api';
-import { emitter } from './utils';
+/* eslint-disable consistent-return */
+import log4js from '@ray-js/log4js';
+import { getSystemInfoSync, usePageEvent } from '@ray-js/ray';
+import { useCallback, useEffect, useRef } from 'react';
+import { SweeperP2pInstance } from './api';
+import { trace } from './trace';
+import { emitter, logger, logP2PDataIfEnabled } from './utils';
 export * from './mqtt';
 export * from './mqtt/type/requestType';
+const useP2PDataStream = (devId, onReceiveMapData, onReceivePathData, opt) => {
+  const traceId = `${devId}_${Date.now()}`;
+  global.robotPanelTraceId = traceId;
+  const {
+    logTag,
+    enableCustomLog = false,
+    onReceiveAIPicData,
+    onReceiveAIPicHDData,
+    onReceiveWifiMapData,
+    onLogger,
+    onDefineStructuredMode
+  } = opt || {};
+  SweeperP2pInstance.enableCustomLog = enableCustomLog;
+  logP2PDataIfEnabled(enableCustomLog, devId, 'hooks_init', `useP2PDataStream initialized, traceId: ${traceId}`);
+  const isInit = useRef(false);
+  const offSessionStatusChange = useRef(null);
+  const isAppOnBackground = useRef(false);
+  const timer = useRef(null);
+  const isIDE = getSystemInfoSync().brand === 'devtools';
+  const handleAppHide = useCallback(() => {
+    logger('info', {
+      msg: 'hooks onAppHide'
+    }, onLogger);
+    logP2PDataIfEnabled(enableCustomLog, devId, 'app_hide', 'Application hidden');
+    isAppOnBackground.current = true;
+    if (isInit.current) {
+      timer.current = setTimeout(() => {
+        logger('info', {
+          msg: `background timer has been exe,isAppOnBackground: ${isAppOnBackground.current}`
+        }, onLogger);
+        if (isAppOnBackground.current) {
+          logP2PDataIfEnabled(enableCustomLog, devId, 'background_timeout', 'Background timeout, unmounting P2P connection');
+          unmount();
+        }
+        clearTimeout(timer.current);
+        timer.current = null;
+      }, 10 * 1000);
+    }
+  }, []);
+  const handleAppShow = useCallback(() => {
+    logger('info', {
+      msg: 'hooks onAppShow'
+    }, onLogger);
+    logger('info', {
+      msg: `clear timer ${timer.current}`
+    }, onLogger);
+    logP2PDataIfEnabled(enableCustomLog, devId, 'app_show', 'Application shown');
+    isAppOnBackground.current = false;
+    timer.current && clearTimeout(timer.current);
+    setTimeout(() => {
+      var _ty$p2p$isP2PActiveSy, _ty$p2p, _ty$p2p$isP2PActiveSy2, _ty$p2p2;
+      logger('info', {
+        msg: `hooks onAppShow and after 500ms : ${isInit.current} isP2PActiveSync: ${(_ty$p2p$isP2PActiveSy = (_ty$p2p = ty.p2p).isP2PActiveSync) === null || _ty$p2p$isP2PActiveSy === void 0 ? void 0 : _ty$p2p$isP2PActiveSy.call(_ty$p2p, {
+          deviceId: devId
+        })}`
+      }, onLogger);
+      if ((!isInit.current || !((_ty$p2p$isP2PActiveSy2 = (_ty$p2p2 = ty.p2p).isP2PActiveSync) !== null && _ty$p2p$isP2PActiveSy2 !== void 0 && _ty$p2p$isP2PActiveSy2.call(_ty$p2p2, {
+        deviceId: devId
+      }))) && !SweeperP2pInstance.isConnecting) {
+        logP2PDataIfEnabled(enableCustomLog, devId, 'app_show_reconnect', 'Reconnecting P2P after app show');
+        connectP2p();
+      }
+    }, 500);
+  }, []);
+  useEffect(() => {
+    if (logTag) {
+      log4js.setTag(logTag);
+    }
+    if (traceId) {
+      trace.traceId = traceId;
+    }
+    if (isIDE) {
+      logger('warn', {
+        msg: `You are using the IDE environment. To perform P2P and map debugging, please ensure the 'Robot Vacuum Debugger' plugin is installed.`
+      }, onLogger);
+      logP2PDataIfEnabled(enableCustomLog, devId, 'ide_mode', 'IDE environment detected, using mock P2P');
+      SweeperP2pInstance.onReceiveMapData = onReceiveMapData;
+      SweeperP2pInstance.onReceivePathData = onReceivePathData;
+      SweeperP2pInstance.onDefineStructuredMode = onDefineStructuredMode;
+      SweeperP2pInstance.registerP2pDownloadEvent();
+      SweeperP2pInstance.onLogger = onLogger;
+      return () => {
+        logP2PDataIfEnabled(enableCustomLog, devId, 'ide_mode_cleanup', 'Cleaning up IDE mode P2P events');
+        SweeperP2pInstance.removeP2pDownloadEvent();
+      };
+    }
+    if (devId.startsWith('vdevo')) {
+      logger('warn', {
+        msg: 'virtual device cannot use p2p'
+      }, onLogger);
+      logP2PDataIfEnabled(enableCustomLog, devId, 'virtual_device', 'Virtual device detected, P2P not available');
+      return;
+    }
+    SweeperP2pInstance.onLogger = onLogger;
+    logP2PDataIfEnabled(enableCustomLog, devId, 'init_p2p_sdk_start', 'Starting P2P SDK initialization');
+    SweeperP2pInstance.initP2pSdk(devId).then(() => {
+      logP2PDataIfEnabled(enableCustomLog, devId, 'init_p2p_sdk_success', 'P2P SDK initialized successfully');
+      connectP2p();
+      trace.pointFn({
+        devId,
+        eventName: 'initP2pSdk'
+      });
+    }).catch(e => {
+      logP2PDataIfEnabled(enableCustomLog, devId, 'init_p2p_sdk_fail', `P2P SDK initialization failed: ${(e === null || e === void 0 ? void 0 : e.message) || 'unknown error'}`);
+      trace.pointFn({
+        devId,
+        eventName: 'initP2pSdkFail'
+      });
+    });
+    ty.onAppHide(handleAppHide);
+    ty.onAppShow(handleAppShow);
+  }, []);
+  usePageEvent('onUnload', () => {
+    logP2PDataIfEnabled(enableCustomLog, devId, 'page_unload', 'Page unloading, cleaning up P2P connection');
+    unmount();
+    ty.offAppHide(handleAppHide);
+    ty.offAppShow(handleAppShow);
+    SweeperP2pInstance.deInitP2PSDK();
+  });
+
+  /**
+   * p2p连接
+   */
+  const connectP2p = async () => {
+    logger('info', {
+      msg: 'hooks has been started connectP2p'
+    }, onLogger);
+    logP2PDataIfEnabled(enableCustomLog, devId, 'connect_p2p_start', 'Starting P2P connection');
+    // 开始进行连接时作为整个p2p连接的开始，将trace的开始时间戳记录下来
+    trace.initTimeStamps = Date.now();
+    SweeperP2pInstance.connectDevice(() => {
+      logP2PDataIfEnabled(enableCustomLog, devId, 'connect_p2p_success', 'P2P connection established successfully');
+      trace.pointFn({
+        devId,
+        eventName: 'connectDeviceSuccess'
+      });
+      isInit.current = true;
+      logP2PDataIfEnabled(enableCustomLog, devId, 'start_observer_data', 'Starting to observe sweeper data by P2P');
+      SweeperP2pInstance.startObserverSweeperDataByP2P(1, devId, onReceiveMapData, onReceivePathData, onReceiveAIPicData, onReceiveAIPicHDData, onReceiveWifiMapData, onDefineStructuredMode);
+      offSessionStatusChange.current = SweeperP2pInstance.onSessionStatusChange(SweeperP2pInstance.sessionStatusCallback);
+    }, () => {
+      logP2PDataIfEnabled(enableCustomLog, devId, 'connect_p2p_fail', 'P2P connection failed, attempting reconnect');
+      trace.pointFn({
+        devId,
+        eventName: 'connectDeviceFail'
+      });
+      SweeperP2pInstance.reconnectP2p(() => {
+        logP2PDataIfEnabled(enableCustomLog, devId, 'reconnect_p2p_success', 'P2P reconnected successfully');
+        isInit.current = true;
+        trace.pointFn({
+          devId,
+          eventName: 'reconnectP2p'
+        });
+        logP2PDataIfEnabled(enableCustomLog, devId, 'start_observer_data_after_reconnect', 'Starting to observe sweeper data after reconnect');
+        SweeperP2pInstance.startObserverSweeperDataByP2P(1, devId, onReceiveMapData, onReceivePathData, onReceiveAIPicData, onReceiveAIPicHDData, onReceiveWifiMapData);
+        // 这里失败重连需要注册断开重连的事件
+        offSessionStatusChange.current = SweeperP2pInstance.onSessionStatusChange(SweeperP2pInstance.sessionStatusCallback);
+      }, '');
+    });
+  };
+
+  /**
+   * p2p断开
+   */
+  const unmount = () => {
+    logger('info', {
+      msg: 'hooks has been started unmount'
+    }, onLogger);
+    logP2PDataIfEnabled(enableCustomLog, devId, 'unmount_p2p', 'Unmounting P2P connection');
+    isInit.current = false;
+    SweeperP2pInstance.stopObserverSweeperDataByP2P();
+    if (offSessionStatusChange.current) {
+      offSessionStatusChange.current();
+      offSessionStatusChange.current = null;
+    }
+  };
+  return {
+    appendDownloadStreamDuringTask: SweeperP2pInstance.appendDownloadStreamDuringTask
+  };
+};
 const StreamDataNotificationCenter = emitter;
 export { StreamDataNotificationCenter, useP2PDataStream };

package/lib/mqtt/createCommonOptions.d.ts

@@ -1,65 +1,24 @@
-import { ProtocolEnum } from './type';
-/**
- * MQTT 消息体类型
- */
-export interface MqttMessage {
-    reqType: string;
-    version: string;
-    taskId: string;
-    [key: string]: string | number | string[] | number[] | boolean | null | undefined;
+interface Message {
+    [key: string]: string | number | string[] | number[] | any;
 }
-/**
- * MQTT 选项类型
- */
-export interface MqttOptions {
+interface Options {
     [key: string]: string;
 }
-/**
- * 创建通用参数的输入参数
- */
-export interface CreateSetCommonParamsInput {
-    /** 设备ID */
+export declare enum ProtocolEnum {
+    appToRobot = 64,
+    robotToApp = 65
+}
+interface Params {
     deviceId: string;
-    /** 请求类型 */
     reqType: string;
-    /** 消息体（可选） */
-    message?: Partial<MqttMessage>;
-    /** 版本号（可选，默认为 1.0.0） */
+    message?: Message;
     version?: string;
-    /** 选项（可选） */
-    options?: MqttOptions;
+    options?: Options;
 }
-/**
- * 创建通用参数的返回类型
- */
-export interface CreateSetCommonParamsOutput {
-    /** 设备ID */
+export declare const createSetCommonParams: ({ deviceId, reqType, message, version, options, }: Params) => {
     deviceId: string;
-    /** 消息体 */
-    message: MqttMessage;
-    /** 选项 */
-    options: MqttOptions;
-    /** 协议号 */
+    message: Message;
+    options: Options;
     protocol: ProtocolEnum;
-}
-/**
- * 创建 MQTT 通用参数
- *
- * @param params - 参数对象
- * @param params.deviceId - 设备ID
- * @param params.reqType - 请求类型
- * @param params.message - 消息体（可选）
- * @param params.version - 版本号（可选，默认为 1.0.0）
- * @param params.options - 选项（可选）
- * @returns MQTT 通用参数对象
- *
- * @example
- * ```ts
- * const params = createSetCommonParams({
- *   deviceId: 'device123',
- *   reqType: 'devInfoQry',
- *   message: { customField: 'value' }
- * });
- * ```
- */
-export declare const createSetCommonParams: ({ deviceId, reqType, message, version, options, }: CreateSetCommonParamsInput) => CreateSetCommonParamsOutput;
+};
+export {};

package/lib/mqtt/createCommonOptions.js

@@ -1,53 +1,17 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import { ProtocolEnum } from './type';
-
-/**
- * MQTT 消息默认版本号
- */
-const DEFAULT_VERSION = '1.0.0';
-
-/**
- * MQTT 消息体类型
- */
-
-/**
- * MQTT 选项类型
- */
-
-/**
- * 创建通用参数的输入参数
- */
-
-/**
- * 创建通用参数的返回类型
- */
-
-/**
- * 创建 MQTT 通用参数
- *
- * @param params - 参数对象
- * @param params.deviceId - 设备ID
- * @param params.reqType - 请求类型
- * @param params.message - 消息体（可选）
- * @param params.version - 版本号（可选，默认为 1.0.0）
- * @param params.options - 选项（可选）
- * @returns MQTT 通用参数对象
- *
- * @example
- * ```ts
- * const params = createSetCommonParams({
- *   deviceId: 'device123',
- *   reqType: 'devInfoQry',
- *   message: { customField: 'value' }
- * });
- * ```
- */
+const defaultVersion = '1.0.0';
+// mqtt协议号
+export let ProtocolEnum = /*#__PURE__*/function (ProtocolEnum) {
+  ProtocolEnum[ProtocolEnum["appToRobot"] = 64] = "appToRobot";
+  ProtocolEnum[ProtocolEnum["robotToApp"] = 65] = "robotToApp";
+  return ProtocolEnum;
+}({});
 export const createSetCommonParams = _ref => {
   let {
     deviceId,
     reqType,
     message = {},
-    version = DEFAULT_VERSION,
+    version = defaultVersion,
     options = {}
   } = _ref;
   const taskId = Date.now();

package/lib/mqtt/mqttProvider.d.ts

@@ -1,29 +1,21 @@
 import React from 'react';
-export interface MqttContextValue {
+export declare const SingletonContext: React.Context<{
     useMqtt: boolean;
     commandVersion: '0' | '1';
     devices: {
-        common: {
-            getDevInfo: () => {
-                devId: string;
-            };
-            model: {
-                props?: any;
-                actions: {
-                    [dpCode: string]: {
-                        set: (command: string) => void;
-                    };
-                };
-            };
-        };
+        common: any;
     };
-}
-export declare const SingletonContext: React.Context<MqttContextValue | null>;
-export interface MqttProviderProps {
-    children: React.ReactNode;
+}>;
+export declare function useMqtt(): {
     useMqtt: boolean;
-    commandVersion: '0' | '1';
-    devices: MqttContextValue['devices'];
-}
-export declare function useMqtt(): MqttContextValue;
-export declare function MqttProvider({ children, useMqtt, commandVersion, devices }: MqttProviderProps): React.JSX.Element;
+    commandVersion: "0" | "1";
+    devices: {
+        common: any;
+    };
+};
+export declare function MqttProvider({ children, useMqtt, commandVersion, devices }: {
+    children: any;
+    useMqtt: any;
+    commandVersion: any;
+    devices: any;
+}): React.JSX.Element;

package/lib/mqtt/mqttProvider.js

@@ -1,18 +1,11 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { get, isNil } from 'lodash-es';
-import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef } from 'react';
+import React, { createContext, useCallback, useContext, useRef, useState } from 'react';
 import { emitter } from '../utils';
-import { ProtocolEnum } from './type';
-
-// Context 类型定义
 
 // 创建一个Context
 export const SingletonContext = /*#__PURE__*/createContext(null);
 
-// MqttProvider Props 类型定义
-
-// MQTT 消息数据类型
-
 // 创建一个自定义Hook来使用这个Context
 export function useMqtt() {
   const context = useContext(SingletonContext);
@@ -28,80 +21,50 @@ export function MqttProvider(_ref) {
     commandVersion,
     devices
   } = _ref;
-  // 使用 useMemo 创建实例，确保只在依赖项变化时重新创建
-  const instance = useMemo(() => ({
-    useMqtt,
-    commandVersion,
-    devices
-  }), [useMqtt, commandVersion, devices]);
-
-  // 使用 ref 存储设备 ID 和初始化状态，避免重复初始化
-  const devIdRef = useRef(null);
-  const isInitializedRef = useRef(false);
-
-  // MQTT 消息处理回调
+  const [instance, setInstance] = useState(null);
   const onMqttMessageReceived = useCallback(data => {
-    var _messageData$errCode;
     const {
       messageData
     } = data || {};
     const reqType = get(messageData, 'reqType', '');
     if (!reqType) return;
-
-    // 确保消息数据包含 success 和 errCode 字段
-    // errCode: 0 表示成功，非 0 表示失败
-    // success: true 表示成功，false 表示失败
-    const errCode = (_messageData$errCode = messageData === null || messageData === void 0 ? void 0 : messageData.errCode) !== null && _messageData$errCode !== void 0 ? _messageData$errCode : (messageData === null || messageData === void 0 ? void 0 : messageData.success) === false ? -1 : 0;
-    const success = isNil(messageData === null || messageData === void 0 ? void 0 : messageData.success) ? errCode === 0 : messageData.success;
-    const responseData = _objectSpread(_objectSpread({}, messageData), {}, {
-      success,
-      errCode
-    });
-    emitter.emit(reqType, responseData);
-  }, []);
-
-  // 初始化 MQTT 监听器（只执行一次）
-  useEffect(() => {
-    // 防止重复初始化
-    if (isInitializedRef.current) return;
-
-    // 获取设备 ID
-    try {
-      const devInfo = devices.common.getDevInfo();
-      devIdRef.current = devInfo.devId;
-    } catch (error) {
-      console.error('Failed to get device info:', error);
-      return;
-    }
-    const devId = devIdRef.current;
-    if (!devId) {
-      console.error('Device ID is not available');
-      return;
+    if (reqType) {
+      console.log('mqtt message received:', reqType, messageData);
+      emitter.emit(reqType, isNil(messageData === null || messageData === void 0 ? void 0 : messageData.success) ? _objectSpread(_objectSpread({}, messageData), {}, {
+        success: true
+      }) : messageData);
     }
+  }, []);
 
-    // 注册 MQTT 协议监听器
+  // 使用ref确保实例只被创建一次
+  const instanceRef = useRef(null);
+  if (instanceRef.current === null) {
+    const {
+      devId
+    } = devices.common.getDevInfo();
     ty.device.registerMQTTProtocolListener({
-      protocol: ProtocolEnum.robotToApp,
+      protocol: 65,
       success: () => {
         console.log('注册mqtt成功');
-      },
-      fail: error => {
-        console.error('注册mqtt失败:', error);
       }
     });
-
-    // 注册 MQTT 消息接收监听器
     ty.device.onMqttMessageReceived(data => {
       if (data.deviceId === devId) {
         onMqttMessageReceived(data);
       }
     });
+    instanceRef.current = {
+      // 是否走mqtt64/65通道
+      useMqtt,
+      // 指令协议版本(1byte or 4bytes)
+      commandVersion,
+      // sdm
+      devices
+    };
+    setInstance(instanceRef.current);
+  }
 
-    // 标记为已初始化
-    isInitializedRef.current = true;
-  }, [devices, onMqttMessageReceived]);
-
-  // 将实例作为 value 传递给消费组件
+  // 将单例状态和行为作为value传递给消费组件
   return /*#__PURE__*/React.createElement(SingletonContext.Provider, {
     value: instance
   }, children);

package/lib/mqtt/myError.d.ts

@@ -0,0 +1,4 @@
+export declare class MyError extends Error {
+    message: any;
+    constructor(message: any, data: any);
+}

package/lib/mqtt/myError.js

@@ -0,0 +1,6 @@
+export class MyError extends Error {
+  constructor(message, data) {
+    super(message);
+    this.message = data;
+  }
+}