@quec/panel-device-kit 1.0.4

package/dist/index.cjs

@@ -0,0 +1,1426 @@
+'use strict';
+
+var QuecRNLogModule = require('@quec/rn-log-module/src/module');
+var QuecRNDeviceModule5 = require('@quec/rn-device-module/src/module');
+var camelCase = require('lodash.camelcase');
+var zustand = require('zustand');
+var react = require('react');
+var reactNative = require('react-native');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var QuecRNLogModule__default = /*#__PURE__*/_interopDefault(QuecRNLogModule);
+var QuecRNDeviceModule5__default = /*#__PURE__*/_interopDefault(QuecRNDeviceModule5);
+var camelCase__default = /*#__PURE__*/_interopDefault(camelCase);
+
+// src/config/DeviceConfig.ts
+var NOT_CONNECTING = 0;
+var DEVICE_TYPE_BIND = 1;
+var DEVICE_TYPE_SHARE = 2;
+var DEVICE_ACCESS_TYPE_DIRECTLY = 0;
+var DEVICE_ACCESS_TYPE_GATEWAY = 1;
+var DEVICE_ACCESS_TYPE_GATEWAY_CHILD = 2;
+var DEVICE_NAME_MAX_LENGTH = 14;
+var onlineStatus = /* @__PURE__ */ ((onlineStatus2) => {
+  onlineStatus2[onlineStatus2["ALL_OFFLINE"] = 0] = "ALL_OFFLINE";
+  onlineStatus2[onlineStatus2["WS_ONLINE"] = 1] = "WS_ONLINE";
+  onlineStatus2[onlineStatus2["WIFI_ONLINE"] = 2] = "WIFI_ONLINE";
+  onlineStatus2[onlineStatus2["WS_WIFI_ONLINE"] = 3] = "WS_WIFI_ONLINE";
+  onlineStatus2[onlineStatus2["BLE_ONLINE"] = 4] = "BLE_ONLINE";
+  onlineStatus2[onlineStatus2["WS_BLE_ONLINE"] = 5] = "WS_BLE_ONLINE";
+  onlineStatus2[onlineStatus2["WIFI_BLE_ONLINE"] = 6] = "WIFI_BLE_ONLINE";
+  onlineStatus2[onlineStatus2["ALL_ONLINE"] = 7] = "ALL_ONLINE";
+  return onlineStatus2;
+})(onlineStatus || {});
+var LOADING_SEND_TIMEOUT = 6e4;
+var BASE_TAG = "\u{1F4AB} Quec_Device_Kit  ";
+var _DeviceKitParamsManager = class _DeviceKitParamsManager {
+  /** 是否使用内部管理器 */
+  static setTSLStore() {
+  }
+  /** 注册回调 */
+  registerCallbacks({
+    loadingCallback,
+    loadingDismissCallback,
+    tipCallback
+  }) {
+    if (loadingCallback) _DeviceKitParamsManager.loadingCallback = loadingCallback;
+    if (loadingDismissCallback)
+      _DeviceKitParamsManager.loadingDismissCallback = loadingDismissCallback;
+    if (tipCallback) _DeviceKitParamsManager.tipCallback = tipCallback;
+  }
+  /** 触发 Loading */
+  loading() {
+    _DeviceKitParamsManager.loadingCallback?.();
+  }
+  /** 关闭 Loading */
+  loadingDismiss() {
+    _DeviceKitParamsManager.loadingDismissCallback?.();
+  }
+  /** 触发提示 */
+  tip(message) {
+    _DeviceKitParamsManager.tipCallback?.(message);
+  }
+  setAutoConnectCurrentDevice(autoConnectCurrentDevice) {
+    _DeviceKitParamsManager.autoConnectCurrentDevice = autoConnectCurrentDevice;
+  }
+  getAutoConnectCurrentDevice() {
+    return _DeviceKitParamsManager.autoConnectCurrentDevice === true;
+  }
+  /** 设置外部日志模块 */
+  static setLogger(logModule) {
+    this.logModule = logModule;
+  }
+  /** 自动关闭所有 console 输出（仅限生产环境） */
+  static autoDisableLog() {
+    const isProduction = !__DEV__;
+    if (isProduction) {
+      const noop = () => {
+      };
+      console.log = noop;
+      console.info = noop;
+      console.warn = noop;
+      console.error = noop;
+      console.debug = noop;
+      console.trace = noop;
+    }
+  }
+  /** 通用日志方法 */
+  log(level, tag, message) {
+    if (typeof message === "object") {
+      message = JSON.stringify(message);
+    }
+    if (_DeviceKitParamsManager.logModule) {
+      _DeviceKitParamsManager.logModule[level](BASE_TAG + tag, "" + message);
+    }
+    console.log(`${BASE_TAG}${tag} ${level} ==> ${"" + message}`);
+  }
+  /** info日志方法 */
+  info(tag, message) {
+    this.log("i", tag, message);
+  }
+  /** err日志方法 */
+  error(tag, message) {
+    this.log("e", tag, message);
+  }
+};
+_DeviceKitParamsManager.useInternalStore = true;
+// 是否使用内部 store，默认 true
+_DeviceKitParamsManager.loadingCallback = null;
+_DeviceKitParamsManager.loadingDismissCallback = null;
+_DeviceKitParamsManager.tipCallback = null;
+_DeviceKitParamsManager.logModule = QuecRNLogModule__default.default;
+var DeviceKitParamsManager = _DeviceKitParamsManager;
+var deviceKitParamsManager = new DeviceKitParamsManager();
+
+// src/utils/to.ts
+async function to(promise, errorExt) {
+  return promise.then((data) => [null, data]).catch((err) => {
+    if (errorExt) {
+      const parsedError = Object.assign({}, err, errorExt);
+      return [parsedError, void 0];
+    }
+    return [err, void 0];
+  });
+}
+var to_default = to;
+
+// src/SDK/getDeviceOnlineState.ts
+var getDeviceOnline = async ({
+  pk,
+  dk
+}) => {
+  const [err, res] = await to_default(
+    QuecRNDeviceModule5__default.default.getDeviceOnlineState(pk, dk)
+  );
+  if (err) {
+    deviceKitParamsManager.error(
+      "\u274C \u2754 getDeviceOnlineState \u83B7\u53D6\u8BBE\u5907\u72B6\u6001\u5931\u8D25",
+      "error ==> " + err
+    );
+    return false;
+  }
+  if (res) {
+    deviceKitParamsManager.info(
+      " \u2705 \u2754 getDeviceOnlineState \u83B7\u53D6\u8BBE\u5907\u72B6\u6001\u6210\u529F",
+      "res ==> " + pk + "_" + dk + JSON.stringify(res)
+    );
+    if (Number(res.onlineState) !== 0) {
+      return true;
+    }
+  }
+  return false;
+};
+var getPropertyDataListWithParams = async (params) => {
+  const { productKey, deviceKey, codeList } = params;
+  deviceKitParamsManager.info(
+    "getPropertyDataListWithParams",
+    "===\u83B7\u53D6\u8BBE\u5907\u5C5E\u6027\u4FE1\u606F:" + productKey + "_" + deviceKey
+  );
+  const [err, res] = await to_default(
+    QuecRNDeviceModule5__default.default.getDeviceBusinessAttributesWithProductKey({
+      ...params,
+      codeList: codeList.join(","),
+      type: "2"
+    })
+  );
+  if (err) {
+    deviceKitParamsManager.error("getDeviceList", "error ==> " + err);
+    deviceKitParamsManager.loadingDismiss();
+    if (err.code && err.code.length > 0) {
+      deviceKitParamsManager.tip(err.message);
+    }
+    return;
+  }
+  if (res && res.data && Array.isArray(res.data?.customizeTslInfo) && res.data?.customizeTslInfo?.length > 0) {
+    deviceKitParamsManager.info(
+      "\u83B7\u53D6\u8BBE\u5907\u5C5E\u6027\u4FE1\u606F",
+      productKey + "_" + deviceKey + "===>" + JSON.stringify(res)
+    );
+    let propertyValueArr = {};
+    codeList.forEach((code) => {
+      const findRes = res.data.customizeTslInfo?.find(
+        (item) => item.resourceCode === code
+      );
+      propertyValueArr[code] = findRes?.resourceValce;
+      propertyValueArr[code + "Id"] = findRes?.abId;
+    });
+    return propertyValueArr;
+  }
+};
+
+// src/utils/stringUtils.ts
+var strToObj = (str) => {
+  if (typeof str === "object" && str !== null) {
+    return str;
+  }
+  if (typeof str === "string" && str.trim() !== "") {
+    try {
+      const res = JSON.parse(str);
+      if (typeof res === "object" && res !== null) {
+        return res;
+      }
+    } catch (error) {
+      deviceKitParamsManager.error("strToObj", error);
+    }
+  }
+  return {};
+};
+var getCircularReplacer = () => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+};
+var objToStr = (obj) => {
+  if (obj instanceof Error) {
+    return obj.stack || obj.message || "Unknown Error";
+  }
+  if (typeof obj === "object") {
+    try {
+      return JSON.stringify(obj, getCircularReplacer(), 2);
+    } catch (e) {
+      return "[Cannot stringify object]";
+    }
+  }
+  if (typeof obj === "undefined") {
+    return "undefined";
+  }
+  if (obj === null) {
+    return "null";
+  }
+  return String(obj);
+};
+
+// src/SDK/subscriDevice.ts
+var subscribeDevice = (pk, dk) => {
+  try {
+    QuecRNDeviceModule5__default.default.subscribeDevice(pk, dk);
+    deviceKitParamsManager.info(
+      "\u2705 \u{1F91D} subscribeDevice \u6210\u529F\u8BA2\u9605\u8BBE\u5907",
+      "pk_dk===>" + pk + "_" + dk
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C \u{1F91D} subscribeDevice \u8BA2\u9605\u8BBE\u5907\u5931\u8D25",
+      "pk_dk===>" + pk + "_" + dk + "   ===> \u5931\u8D25\u539F\u56E0\uFF1A" + objToStr(error)
+    );
+  }
+};
+
+// src/deviceListStore.ts
+var DEFAULT_PAGE_NUM = 1;
+var DEFAULT_PAGE_SIZE = 15;
+var initialState = {
+  deviceList: [],
+  total: null,
+  networkError: false,
+  listIsEmpty: false,
+  deviceListPlus: [],
+  //提供给自己想要简化device的数据的开发
+  subscribeDevicesList: [],
+  pageNum: DEFAULT_PAGE_NUM,
+  pageSize: DEFAULT_PAGE_SIZE,
+  canLoadMore: false
+};
+var deviceListStore = null;
+var createDeviceListStore = (params) => {
+  const {
+    pageSize = DEFAULT_PAGE_SIZE,
+    processDeviceList,
+    isSubScribeAllDevice = false,
+    subscribeCodeList
+  } = params || {};
+  if (pageSize <= 1 || !Number.isInteger(pageSize)) {
+    throw new Error("\u274C  pageSize\u8981\u6C42\u662F\u6B63\u6574\u6570\u4E14\u5927\u4E8E\u7B49\u4E8E1");
+  } else {
+    DEFAULT_PAGE_SIZE = pageSize;
+  }
+  if (!deviceListStore) {
+    deviceListStore = zustand.create((set, get) => ({
+      ...initialState,
+      //   刷新设备列表
+      refreshDeviceList(successCallback, failCallback) {
+        let deviceList = [];
+        set({
+          deviceList,
+          pageNum: 1,
+          canLoadMore: false
+        });
+        get().getDeviceList(
+          1,
+          get().pageSize,
+          (list, canLoadMore) => {
+            successCallback && successCallback(list);
+          },
+          failCallback
+        );
+      },
+      //   加载更多设备列表
+      loadMoreDeviceList(successCallback, failCallback) {
+        if (get().canLoadMore) {
+          get().getDeviceList(
+            get().pageNum,
+            get().pageSize,
+            (list, canLoadMore) => {
+              successCallback && successCallback(list);
+            },
+            failCallback
+          );
+        }
+      },
+      //   请求设备列表
+      async getDeviceList(pageNum, paseSize, successCallback, failCallback) {
+        deviceKitParamsManager.loading();
+        const [err, res] = await to_default(
+          QuecRNDeviceModule5__default.default.getDeviceListWithPageNumber(pageNum, paseSize)
+        );
+        if (err) {
+          deviceKitParamsManager.error("\u274C  getDeviceList", "\u83B7\u53D6\u8BBE\u5907\u5217\u8868error ==> " + err);
+          deviceKitParamsManager.loadingDismiss();
+          if (err.code && err.code.length > 0) {
+            deviceKitParamsManager.tip(err.message);
+          }
+          set({
+            networkError: true
+          });
+          failCallback && failCallback(err);
+          return;
+        }
+        let returnSuccessDeviceList = [];
+        if (res && res.data && res.data.list && Array.isArray(res.data?.list)) {
+          deviceKitParamsManager.info("getDeviceList", "res ==> " + objToStr(res));
+          const { data } = res;
+          const { list } = data;
+          set({ total: data.total });
+          if (pageNum === 1) {
+            await get().updateDeviceList(list);
+            returnSuccessDeviceList = list;
+            successCallback && successCallback(returnSuccessDeviceList, data.total > list.length);
+            if (deviceKitParamsManager.getAutoConnectCurrentDevice() && list.length > 0) {
+              deviceKitParamsManager.info("getDeviceList", "auto connect device");
+              QuecRNDeviceModule5__default.default.connectChannel(0);
+            }
+            set({
+              canLoadMore: data.total > list.length,
+              pageNum: data.total > list.length ? pageNum + 1 : 1
+            });
+          } else {
+            const nextListRes = list;
+            const preDevicesList = [...get().deviceList, ...nextListRes];
+            await get().updateDeviceList(preDevicesList);
+            returnSuccessDeviceList = list;
+            successCallback && successCallback(returnSuccessDeviceList, data.total > preDevicesList.length);
+            set({
+              canLoadMore: data.total > preDevicesList.length,
+              pageNum: data.total > preDevicesList.length ? pageNum + 1 : pageNum
+            });
+          }
+        } else {
+          deviceKitParamsManager.error("getDeviceList", "no res ==> " + objToStr(res));
+          failCallback && failCallback(null);
+        }
+        deviceKitParamsManager.loadingDismiss();
+      },
+      //   更新设备列表
+      async updateDeviceList(deviceList) {
+        set({
+          listIsEmpty: Array.isArray(deviceList) && deviceList.length === 0,
+          deviceList,
+          networkError: deviceList === void 0
+        });
+        if (!!processDeviceList && processDeviceList instanceof Function) {
+          await get().updateDeviceListPlus(deviceList);
+        }
+      },
+      //   处理更新的设备列表数据使其符合自己使用的习惯
+      async updateDeviceListPlus(devicesArr) {
+        const deviceListPlus = devicesArr.filter(
+          (item) => item.deviceKey !== void 0 && item.productKey !== void 0 && item.deviceKey !== null && item.productKey !== null
+        ).map((item) => processDeviceList(item));
+        if (!isSubScribeAllDevice) {
+          set({
+            deviceListPlus
+          });
+          return;
+        }
+        for (let i = 0; i < deviceListPlus.length; i++) {
+          const item = deviceListPlus[i];
+          get().addSubscribeDeviceList(item.productKey, item.deviceKey);
+          const isOnline = await getDeviceOnline({
+            pk: item.productKey,
+            dk: item.deviceKey
+          });
+          item.isOnline = isOnline;
+          if (!(subscribeCodeList && subscribeCodeList?.length > 0)) {
+            return;
+          }
+          const propertyData = await getPropertyDataListWithParams({
+            productKey: item.productKey,
+            deviceKey: item.deviceKey,
+            codeList: subscribeCodeList
+          });
+          for (let index = 0; index < subscribeCodeList.length; index++) {
+            const subscribeModelCode = subscribeCodeList[index];
+            if (propertyData && propertyData[subscribeModelCode]) {
+              deviceListPlus[i].subscribeModel[camelCase__default.default(subscribeModelCode)] = Number(
+                propertyData[subscribeModelCode]
+              );
+              deviceListPlus[i].subscribeModel[camelCase__default.default(subscribeModelCode) + "Id"] = Number(
+                propertyData[subscribeModelCode + "Id"]
+              );
+            }
+          }
+        }
+        set({
+          deviceListPlus
+        });
+      },
+      /**
+       * 更新列表中单个设备的在离线状态
+       * @param event
+       */
+      updateDeviceOnlineState(event) {
+        const deviceListPlus = [...get().deviceListPlus];
+        const eventDevice = typeof event?.device === "object" ? event?.device : JSON.parse(event?.device ?? "{}");
+        deviceListPlus.forEach((item) => {
+          if (item.deviceKey === eventDevice?.deviceKey && item.productKey === eventDevice?.productKey && event?.onlineState !== void 0 && !Number.isNaN(Number(event.onlineState))) {
+            item.isOnline = Number(event.onlineState) !== 0;
+            item.onlineState = Number(event.onlineState);
+          }
+        });
+        set({
+          deviceListPlus
+        });
+      },
+      /**
+       * 更新列表中单个设备的物模型
+       * @param deviceListPlus
+       */
+      updateDeviceDPSData(event) {
+        if (!isSubScribeAllDevice || !subscribeCodeList || subscribeCodeList?.length <= 0) {
+          return;
+        }
+        const { dps, dk, pk } = event;
+        if (dps === void 0 || dps === null || dk === void 0 || dk === null || pk === void 0 || pk === null) {
+          return;
+        } else {
+          const deviceListPlus = [...get().deviceListPlus];
+          deviceListPlus.forEach((device) => {
+            if (device.deviceKey === event.dk && device.productKey === event.pk) {
+              dps.map((item) => {
+                Object.entries(device.subscribeModel).forEach(([key, value]) => {
+                  if (key.endsWith("Id")) {
+                    const modelId = value;
+                    if (modelId === item.id) {
+                      device.subscribeModel[key] = item.value;
+                    }
+                  }
+                });
+              });
+            }
+          });
+          set({
+            deviceListPlus
+          });
+        }
+      },
+      /**
+       * 增加已订阅设备列表并订阅设备
+       * @param deviceList
+       */
+      addSubscribeDeviceList(pk, dk) {
+        const subscribeDevicesListCopy = [...get().subscribeDevicesList];
+        if (subscribeDevicesListCopy.find((item) => {
+          item.dk === dk && item.pk === pk;
+        }) === void 0) {
+          subscribeDevicesListCopy.push({ pk, dk });
+          subscribeDevice(pk, dk);
+        }
+        set({
+          subscribeDevicesList: subscribeDevicesListCopy
+        });
+      }
+    }));
+  }
+  return deviceListStore;
+};
+var getDeviceListStore = () => {
+  if (!deviceListStore) {
+    throw new Error("\u2757\u8BF7\u5148\u8C03\u7528 createDeviceListStore() \u521D\u59CB\u5316 Store");
+  }
+  return deviceListStore;
+};
+var getDeviceListStoreWithoutError = () => {
+  if (!deviceListStore) {
+    return null;
+  }
+  return deviceListStore;
+};
+var selectFromStore = (selector) => {
+  const store = getDeviceListStore();
+  return store(selector);
+};
+var useDeviceListStoreState = () => {
+  return selectFromStore((state) => state);
+};
+var useDeviceList = () => {
+  return selectFromStore((state) => state.deviceList);
+};
+var useDeviceListLoadMore = () => {
+  return selectFromStore((state) => state.loadMoreDeviceList);
+};
+var useDeviceListRefresh = () => {
+  return selectFromStore((state) => state.refreshDeviceList);
+};
+var getDeviceOnlineState = async ({
+  productKey,
+  deviceKey
+}) => {
+  try {
+    const { onlineState } = await QuecRNDeviceModule5__default.default.getDeviceOnlineState(productKey, deviceKey);
+    deviceKitParamsManager.info(
+      "\u{1F50E}QuecRNDeviceModule.getDeviceOnlineState....",
+      "\u83B7\u53D6\u8BBE\u5907\u72B6\u6001 ===> onlineState:" + onlineState
+    );
+    return onlineState;
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274CQuecRNDeviceModule.getDeviceOnlineState(\u83B7\u53D6\u8BBE\u5907\u72B6\u6001\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    return null;
+  }
+};
+var getDeviceConnectingState = async () => {
+  try {
+    const result = await QuecRNDeviceModule5__default.default.getDeviceConnectingState();
+    deviceKitParamsManager.info(
+      "\u{1F4F6} QuecRNDeviceModule.getDeviceConnectingState",
+      `\u5F53\u524D\u8FDE\u63A5\u72B6\u6001\uFF1A${result?.connectingState}`
+    );
+    return result?.connectingState;
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.getDeviceConnectingState(\u83B7\u53D6\u8FDE\u63A5\u72B6\u6001\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw null;
+  }
+};
+var disconnectChannel = (type) => {
+  try {
+    QuecRNDeviceModule5__default.default.disconnectChannel(type);
+    deviceKitParamsManager.info(
+      "\u{1F502} QuecRNDeviceModule.disconnectChannel",
+      `\u65AD\u5F00\u8BBE\u5907\u8FDE\u63A5\u901A\u9053\u6210\u529F\uFF0C\u901A\u9053\u7C7B\u578B\uFF1A${type}`
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.disconnectChannel(\u65AD\u5F00\u8BBE\u5907\u8FDE\u63A5\u901A\u9053\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+  }
+};
+var connectChannel = (mode) => {
+  try {
+    QuecRNDeviceModule5__default.default.connectChannel(mode);
+    deviceKitParamsManager.info(
+      "\u{1F502} QuecRNDeviceModule.connectChannel",
+      `\u5EFA\u7ACB\u8BBE\u5907\u8FDE\u63A5\u901A\u9053\u6210\u529F\uFF0C\u901A\u9053\u7C7B\u578B\uFF1A${mode}`
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.connectChannel(\u5EFA\u7ACB\u8BBE\u5907\u8FDE\u63A5\u901A\u9053\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+  }
+};
+var getProductDescription = async (productKey) => {
+  try {
+    const { data } = await QuecRNDeviceModule5__default.default.getProductDescription(productKey);
+    deviceKitParamsManager.info(
+      "\u{1F4D8} QuecRNDeviceModule.getProductDescription",
+      `\u8BF4\u660E\u4E66\u5730\u5740\uFF1A${objToStr(data)}`
+    );
+    if (data?.url === void 0 || data?.url === "") {
+      return null;
+    }
+    return data.url;
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.getProductDescription(\u83B7\u53D6\u8BF4\u660E\u4E66\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    return null;
+  }
+};
+
+// src/types/Error.ts
+function createCustomError(name, defaultCode) {
+  return class CustomError extends Error {
+    constructor(code, message) {
+      super(message);
+      this.name = name;
+      this.code = code;
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  };
+}
+var GetDeviceInfoError = createCustomError(
+  "\u{1F4FA} GetDeviceInfoError");
+
+// src/utils/empty.ts
+var EmptyARR = [null, void 0, ""];
+var isEmpty = (value) => {
+  return EmptyARR.some((empty) => {
+    if (typeof empty === "object" && empty !== null) {
+      return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+    }
+    return value === empty;
+  });
+};
+
+// src/utils/numberUtils.ts
+var handlerNumberVal = (val, final) => {
+  let nextNumber = Number(val);
+  nextNumber = Number.isNaN(nextNumber) ? final : nextNumber;
+  return nextNumber;
+};
+var trueNumber = (val, final = 0) => {
+  return handlerNumberVal(val, final);
+};
+
+// src/deviceStore.ts
+var initialState2 = {
+  device: null,
+  props: null,
+  isOnlyBle: false,
+  productUrl: null,
+  family: null,
+  area: null,
+  deviceIsEmpty: false,
+  deviceSate: 1,
+  connectingState: 0,
+  online: true,
+  wsOnline: true,
+  lanOnline: false,
+  bleOnline: false
+};
+var deviceStore = null;
+var createDeviceStore = ({
+  offlineTip,
+  onlineTip
+}) => {
+  if (!deviceStore) {
+    deviceStore = zustand.create((set, get) => ({
+      ...initialState2,
+      useSetProps: (propsSource) => {
+        if (isEmpty(propsSource)) {
+          deviceKitParamsManager.error(
+            "\u274C\u5904\u7406props\u5931\u8D25",
+            "\u5F53\u524Dprops\u6CA1\u6709\u521D\u59CB\u5316\uFF0Capp\u4F20\u5165\u7684\u4FE1\u606F\u4E3A\u7A7A props ==>" + objToStr(propsSource)
+          );
+          return null;
+        } else {
+          deviceKitParamsManager.info(" \u{1F680}\u5904\u7406props \u25B6 ", propsSource);
+        }
+        let props = typeof propsSource === "string" || typeof propsSource === "object" ? strToObj(propsSource) : null;
+        set({
+          props
+        });
+        if (props?.area) {
+          set({
+            area: props.area
+          });
+        }
+        if (props?.endUserId) {
+          set({
+            endUserId: props.endUserId
+          });
+        }
+        if (props?.userAccount) {
+          set({
+            userAccount: props.userAccount
+          });
+        }
+        if (props?.familyModeEnabled && props?.familyRole) {
+          set({
+            family: {
+              familyModeEnabled: props?.familyModeEnabled,
+              familyRole: props?.familyRole
+            }
+          });
+        }
+        let deviceSource = props?.device;
+        let device = deviceSource === void 0 ? null : strToObj(deviceSource);
+        if (isEmpty(device)) {
+          deviceKitParamsManager.error(
+            "\u274C\u5904\u7406device\u5931\u8D25",
+            "\u5F53\u524Ddevice\u6CA1\u6709\u521D\u59CB\u5316\uFF0C\u8BBE\u5907\u4FE1\u606F\u4E3A\u7A7A device ==>" + objToStr(device)
+          );
+          set({ deviceIsEmpty: true });
+          return props;
+        } else {
+          set({ deviceIsEmpty: false });
+          deviceKitParamsManager.info(" \u{1F680}\u5904\u7406device \u25B6 ", device);
+          get().getProductManual(device.productKey);
+        }
+        set({
+          device,
+          isOnlyBle: (device?.capabilitiesBitmask && 4) === 4 && device?.verified === "0" || device?.capabilitiesBitmask === 4
+        });
+        return props;
+      },
+      updateDevice: (device) => {
+        if (isEmpty(device)) {
+          deviceKitParamsManager.error(
+            "\u274C\u5904\u7406device\u5931\u8D25",
+            "device\u4E3A\u7A7A newDevice ==>" + objToStr(device)
+          );
+          set({ deviceIsEmpty: true });
+          return;
+        }
+        set({ deviceIsEmpty: false });
+        const newDevice = typeof device === "string" ? strToObj(device) : device;
+        deviceKitParamsManager.info("\u2705 \u65B0\u7684device \u25B6 ", newDevice);
+        set({
+          device: newDevice
+        });
+        get().getProductManual(newDevice.productKey);
+        get().getDeviceState();
+      },
+      updateDeviceName: (newName) => {
+        if (isEmpty(newName) || isEmpty(get().device)) {
+          deviceKitParamsManager.error(
+            "\u274C\u5904\u7406deviceName\u5931\u8D25",
+            "newName\u6216\u8005device\u4E3A\u7A7A newName ==>" + objToStr(newName)
+          );
+          return;
+        }
+        deviceKitParamsManager.info("\u2705 \u65B0\u7684deviceName \u25B6 ", newName);
+        const deviceNew = get().device;
+        if (deviceNew) {
+          deviceNew.deviceName = newName;
+          set({
+            device: deviceNew
+          });
+        }
+      },
+      getDeviceState: async () => {
+        try {
+          const { onlineState } = await QuecRNDeviceModule5__default.default.getOnlineState();
+          deviceKitParamsManager.info(
+            "\u{1F50E}QuecRNDeviceModule.getOnlineState....",
+            "\u83B7\u53D6\u8BBE\u5907\u72B6\u6001 ===> onlineState:" + onlineState
+          );
+          get().updateOnlineStatus(onlineState);
+          return onlineState;
+        } catch (error) {
+          deviceKitParamsManager.error("\u274C\u83B7\u53D6\u8BBE\u5907\u72B6\u6001\u5931\u8D25", "\u5931\u8D25\u539F\u56E0===> " + objToStr(error));
+          return null;
+        }
+      },
+      updateOnlineStatus: (deviceSate) => {
+        deviceSate = Number(deviceSate);
+        let nextOnlineState = trueNumber(deviceSate, 0 /* ALL_OFFLINE */);
+        if (nextOnlineState === get().deviceSate) {
+          return;
+        }
+        const online = nextOnlineState !== 0 /* ALL_OFFLINE */;
+        if (!online) {
+          offlineTip && offlineTip();
+        } else {
+          onlineTip && onlineTip();
+        }
+        set({
+          deviceSate,
+          online,
+          wsOnline: (deviceSate & 1 /* WS_ONLINE */) === 1 /* WS_ONLINE */,
+          lanOnline: (deviceSate & 2 /* WIFI_ONLINE */) === 2 /* WIFI_ONLINE */,
+          bleOnline: (deviceSate & 4 /* BLE_ONLINE */) === 4 /* BLE_ONLINE */
+        });
+      },
+      getDeviceConnectingState: async () => {
+        const connectingState = await getDeviceConnectingState();
+        set({
+          connectingState: connectingState ?? 0
+        });
+      },
+      updateConnectingState: (connectingState) => {
+        set({
+          connectingState
+        });
+      },
+      getProductManual: async (productKey) => {
+        const finalProductKey = productKey ?? get().device?.productKey;
+        if (finalProductKey === void 0) {
+          deviceKitParamsManager.error(
+            "\u{1F4D6}getProductManual",
+            `\u274C getProductDescription error====\uFF08\u83B7\u53D6\u8BF4\u660E\u4E66\u9519\u8BEF\uFF09==>  there is not productKey(value:${productKey}) for getProductManual params`
+          );
+          return;
+        }
+        const url = await getProductDescription(finalProductKey);
+        set({ productUrl: url });
+      },
+      checkCurrentDeviceExist: async () => {
+        const currentDevice = get().device;
+        deviceKitParamsManager.info(
+          "\u{1F4FA} checkCurrentDeviceExist device.name \u25B6",
+          currentDevice?.deviceName
+        );
+        if (!currentDevice) {
+          deviceKitParamsManager.error("\u{1F4FA} \u5F53\u524D\u6CA1\u6709\u9009\u4E2D\u7684\u8BBE\u5907", currentDevice);
+          return void 0;
+        }
+        try {
+          const res = currentDevice?.isShared === true ? await get().getShareDeviceInfo() : await get().getDeviceInfo();
+          const exist = !!res;
+          deviceKitParamsManager.info("\u{1F4FA} \u5F53\u524D\u8BBE\u5907\u662F\u5426\u5B58\u5728 \u25B6", exist);
+          return exist;
+        } catch (e) {
+          if (e instanceof GetDeviceInfoError) {
+            switch (e.code) {
+              case "request_failed":
+              case "no_device":
+                deviceKitParamsManager.info("\u{1F4FA} \u8BBE\u5907\u4E0D\u5B58\u5728\u6216\u8BF7\u6C42\u5931\u8D25\uFF0C\u5224\u5B9A\u4E3A\u4E0D\u5B58\u5728", e.message);
+                return false;
+              case "invalid_param":
+                deviceKitParamsManager.error("\u{1F4FA} \u53C2\u6570\u65E0\u6548\uFF0C\u65E0\u6CD5\u5224\u65AD\u8BBE\u5907\u662F\u5426\u5B58\u5728", e.message);
+                return void 0;
+              default:
+                deviceKitParamsManager.error("\u{1F4FA} \u672A\u77E5\u9519\u8BEF\u7801", e);
+                return void 0;
+            }
+          } else {
+            deviceKitParamsManager.error("\u{1F4FA} \u975E\u9884\u671F\u9519\u8BEF", e);
+            return void 0;
+          }
+        }
+      },
+      getDeviceInfo: async (deviceKey, productKey) => {
+        const finalDeviceKey = deviceKey || get().device?.deviceKey;
+        const finalProductKey = productKey || get().device?.productKey;
+        deviceKitParamsManager.info(
+          "\u{1F4FA} getDeviceInfoByDeviceKey params \u25B6",
+          `${finalDeviceKey}_${finalProductKey}`
+        );
+        if (!finalDeviceKey || !finalProductKey) {
+          throw new GetDeviceInfoError("invalid_param", "deviceKey \u6216 productKey \u4E0D\u5B8C\u6574");
+        }
+        const [err, res] = await to_default(
+          QuecRNDeviceModule5__default.default.getDeviceInfoByDeviceKey(finalDeviceKey, finalProductKey)
+        );
+        if (err) {
+          throw new GetDeviceInfoError(
+            "no_device",
+            `\u8BF7\u6C42\u5931\u8D25,\u8BBE\u5907\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u79FB\u9664: ${err.message || err}`
+          );
+        }
+        if (!res) {
+          throw new GetDeviceInfoError("no_device", "\u8BBE\u5907\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u79FB\u9664");
+        }
+        deviceKitParamsManager.info("\u{1F4FA} getDeviceInfoByDeviceKey res \u25B6", res);
+        return res;
+      },
+      getShareDeviceInfo: async (shareCode) => {
+        deviceKitParamsManager.info("\u{1F4FA} getShareDeviceInfo shareCode \u25B6", shareCode);
+        const finalShareCode = shareCode || get().device?.shareCode;
+        if (!finalShareCode) {
+          throw new GetDeviceInfoError("invalid_param", "\u53C2\u6570\u65E0\u6548\uFF1A\u7F3A\u5C11 shareCode");
+        }
+        const [err, res] = await to_default(
+          QuecRNDeviceModule5__default.default.getDeviceInfoByShareCode(finalShareCode)
+        );
+        if (err) {
+          throw new GetDeviceInfoError(
+            "no_device",
+            `\u8BF7\u6C42\u5931\u8D25,\u8BBE\u5907\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u79FB\u9664: ${err.message || err}`
+          );
+        }
+        if (!res) {
+          throw new GetDeviceInfoError("no_device", "\u8BBE\u5907\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u79FB\u9664");
+        }
+        deviceKitParamsManager.info("\u{1F4FA} getShareDeviceInfo res \u25B6", res);
+        return res;
+      }
+    }));
+  }
+  return deviceStore;
+};
+var getDeviceStore = () => {
+  if (!deviceStore) {
+    throw new Error("\u2757\u8BF7\u5148\u8C03\u7528 createDeviceStore() \u521D\u59CB\u5316 deviceStore");
+  }
+  return deviceStore;
+};
+var getDeviceStoreWithoutError = () => {
+  if (!deviceStore) {
+    return null;
+  }
+  return deviceStore;
+};
+var selectFromStore2 = (selector) => {
+  const store = getDeviceStore();
+  return store(selector);
+};
+var useDeviceStoreState = () => selectFromStore2((state) => state);
+var useDevice = () => selectFromStore2((state) => state.device);
+var useDeviceProps = () => selectFromStore2((state) => state.props);
+var useDeviceFamily = () => selectFromStore2((state) => state.family);
+var useDeviceArea = () => selectFromStore2((state) => state.area);
+var useDeviceProductUrl = () => selectFromStore2((state) => state.productUrl);
+var useEndUserId = () => selectFromStore2((state) => state.endUserId);
+var useUserAccount = () => selectFromStore2((state) => state.userAccount);
+var useDeviceIsOnlyBle = () => selectFromStore2((state) => state.isOnlyBle);
+var useDeviceOnline = () => selectFromStore2((state) => state.online);
+var useDeviceState = () => selectFromStore2((state) => state.deviceSate);
+var useDeviceWsOnline = () => selectFromStore2((state) => state.wsOnline);
+var useDeviceLanOnline = () => selectFromStore2((state) => state.lanOnline);
+var useDeviceBleOnline = () => selectFromStore2((state) => state.bleOnline);
+var useDeviceIsConnecting = () => selectFromStore2((state) => Number(state.connectingState) !== 0);
+var useGetDeviceStatus = () => selectFromStore2((state) => state.getDeviceState);
+var useUpdateDeviceConnectingState = () => selectFromStore2((state) => state.updateConnectingState);
+var useSetProps = () => selectFromStore2((state) => state.useSetProps);
+var useUpdateDevice = () => selectFromStore2((state) => state.updateDevice);
+var useUpdateDeviceName = () => selectFromStore2((state) => state.updateDeviceName);
+var useUpdateOnlineStatus = () => selectFromStore2((state) => state.updateOnlineStatus);
+var useCheckCurrentDeviceExist = () => selectFromStore2((state) => state.checkCurrentDeviceExist);
+var EVENT_TYPE_DEVICE_ONLINE = "onDeviceOnlineState";
+var EVENT_TYPE_DEVICE_CONNECTING = "onDeviceConnectingState";
+var eventEmitter = new reactNative.NativeEventEmitter(reactNative.NativeModules.QuecRNDeviceModule);
+var onDeviceStateUpdateListener;
+var onDeviceConnectingStateUpdateListener;
+var useInitUpdateDeviceStateEvent = (updateDeviceStateCallback, updateDeviceConnectingStateCallback) => {
+  const deviceListStore2 = getDeviceListStoreWithoutError();
+  const deviceListStoreState = deviceListStore2 ? deviceListStore2((state) => state) : null;
+  if (deviceListStoreState === null) {
+    deviceKitParamsManager.info(
+      "PS\uFF1A\u5982\u679C\u4F60\u4E0D\u4F7F\u7528\u8BBE\u5907\u4FE1\u606F\u72B6\u6001\u7BA1\u7406\uFF0C\u8BF7\u5FFD\u7565\u6B64\u8B66\u544A",
+      "WARNING   \u4F60\u672A\u521D\u59CB\u5316 createDeviceListStore "
+    );
+  }
+  const updateDeviceOnlineState = deviceListStoreState?.updateDeviceOnlineState ?? null;
+  const deviceStore2 = getDeviceStoreWithoutError();
+  const deviceStoreState = deviceStore2 ? deviceStore2((state) => state) : null;
+  if (deviceStoreState === null) {
+    deviceKitParamsManager.info(
+      "PS\uFF1A\u5982\u679C\u4F60\u4E0D\u4F7F\u7528\u8BBE\u5907\u5217\u8868\u4FE1\u606F\u72B6\u6001\u7BA1\u7406\uFF0C\u8BF7\u5FFD\u7565\u6B64\u8B66\u544A",
+      "WARNING   \u4F60\u672A\u521D\u59CB\u5316 createDeviceStore "
+    );
+  }
+  const updateOnlineStatus = deviceStoreState?.updateOnlineStatus ?? null;
+  const updateConnectingState = deviceStoreState?.updateConnectingState ?? null;
+  const device = deviceStoreState?.device ?? null;
+  react.useEffect(() => {
+    removeListener(onDeviceStateUpdateListener);
+    onDeviceStateUpdateListener = eventEmitter.addListener(
+      EVENT_TYPE_DEVICE_ONLINE,
+      (event) => {
+        deviceKitParamsManager.info(
+          EVENT_TYPE_DEVICE_ONLINE,
+          " \u{1F91D} ==OnlineState==" + objToStr(event)
+        );
+        if (isEmpty(event)) {
+          return;
+        }
+        const eventDevice = strToObj(event.device);
+        if (device?.deviceKey === eventDevice?.deviceKey && device?.productKey === eventDevice?.productKey && updateOnlineStatus) {
+          updateOnlineStatus(event.onlineState);
+        }
+        if (updateDeviceOnlineState) {
+          updateDeviceOnlineState(event);
+        }
+        updateDeviceStateCallback && updateDeviceStateCallback(event);
+      }
+    );
+    return () => {
+      removeListener(onDeviceStateUpdateListener);
+      onDeviceStateUpdateListener = null;
+    };
+  }, [updateDeviceOnlineState, updateOnlineStatus, device]);
+  react.useEffect(() => {
+    removeListener(onDeviceConnectingStateUpdateListener);
+    onDeviceConnectingStateUpdateListener = eventEmitter.addListener(
+      EVENT_TYPE_DEVICE_ONLINE,
+      (event) => {
+        deviceKitParamsManager.info(
+          EVENT_TYPE_DEVICE_CONNECTING,
+          " \u26A1  ==ConnectingState==" + objToStr(event)
+        );
+        const connectingState = isNaN(event?.connectingState) ? 0 : Number(event?.connectingState);
+        updateConnectingState && updateConnectingState(connectingState);
+        updateDeviceConnectingStateCallback && updateDeviceConnectingStateCallback(event);
+      }
+    );
+    return () => {
+      removeListener(onDeviceConnectingStateUpdateListener);
+      onDeviceConnectingStateUpdateListener = null;
+    };
+  }, [updateConnectingState, updateDeviceConnectingStateCallback]);
+};
+var removeListener = (listener) => {
+  if (listener) {
+    listener.remove();
+    listener = void 0;
+  }
+};
+
+// src/device-list-utils.ts
+var QuecRNBusinessPanelModule = {
+  changeBusinessPanel: (params) => {
+    console.warn("QuecRNBusinessPanelModule.changeBusinessPanel is not available", params);
+  },
+  switchBusinessPanel: () => {
+    console.warn("QuecRNBusinessPanelModule.switchBusinessPanel is not available");
+  }
+};
+var changeDevicePanel = (newDevice) => {
+  deviceKitParamsManager.info(
+    "changeDevicePanel",
+    "__\u66F4\u6362\u8BBE\u5907\u9762\u677F => \u8BBE\u5907\uFF1A" + newDevice.deviceName
+  );
+  QuecRNBusinessPanelModule.changeBusinessPanel({
+    device: JSON.stringify(newDevice)
+  });
+};
+var checkoutEmptyPanel = () => {
+  deviceKitParamsManager.info("checkoutEmptyPanel", "__\u66F4\u6362\u6258\u5E95\u9762\u677F");
+  QuecRNBusinessPanelModule.switchBusinessPanel();
+};
+
+// src/initDeviceListUpdate.ts
+var EVENT_TYPE_REFRESH_DEVICE_LIST = "QuecRefreshDeviceList";
+var refreshDeviceListListener;
+var panelEventEmitter = new reactNative.NativeEventEmitter(reactNative.NativeModules.QuecRNBusinessPanelModule);
+var useInitDeviceListUpdateEvent = (params) => {
+  const {
+    refreshDeviceListEventCallback,
+    refreshDeviceListSuccessCallback,
+    enableAutoCheckoutDevice
+  } = params ?? {};
+  const deviceListStore2 = getDeviceListStoreWithoutError();
+  const deviceListStoreState = deviceListStore2 ? deviceListStore2((state) => state) : null;
+  if (deviceListStoreState === null) {
+    deviceKitParamsManager.info(
+      "PS\uFF1A\u5982\u679C\u4F60\u4E0D\u4F7F\u7528\u8BBE\u5907\u5217\u8868\u4FE1\u606F\u72B6\u6001\u7BA1\u7406\uFF0C\u8BF7\u5FFD\u7565\u6B64\u8B66\u544A",
+      "WARNING   \u4F60\u672A\u521D\u59CB\u5316 createDeviceListStore "
+    );
+  }
+  const deviceStore2 = getDeviceStoreWithoutError();
+  const deviceStoreState = deviceStore2 ? deviceStore2((state) => state) : null;
+  if (deviceStoreState === null) {
+    deviceKitParamsManager.info(
+      "PS\uFF1A\u5982\u679C\u4F60\u4E0D\u4F7F\u7528\u8BBE\u5907\u4FE1\u606F\u72B6\u6001\u7BA1\u7406\uFF0C\u8BF7\u5FFD\u7565\u6B64\u8B66\u544A",
+      "WARNING   \u4F60\u672A\u521D\u59CB\u5316 createDeviceStore "
+    );
+  }
+  const listIsEmpty = deviceListStoreState?.listIsEmpty ?? null;
+  const refreshDeviceList = deviceListStoreState?.refreshDeviceList ?? null;
+  const device = deviceStoreState?.device ?? null;
+  const deviceIsEmpty = deviceStoreState?.deviceIsEmpty ?? null;
+  const checkCurrentDeviceExist = deviceStoreState?.checkCurrentDeviceExist ?? null;
+  const [onceCheckNowDevice, setOnceCheckNowDevice] = react.useState(true);
+  react.useEffect(() => {
+    removeListener2(refreshDeviceListListener);
+    refreshDeviceListListener = panelEventEmitter.addListener(
+      EVENT_TYPE_REFRESH_DEVICE_LIST,
+      (event) => {
+        deviceKitParamsManager.info(EVENT_TYPE_REFRESH_DEVICE_LIST, "==refresh device list \u{1F504}==");
+        refreshDeviceList && refreshDeviceList((list) => {
+          refreshDeviceListSuccessCallback && refreshDeviceListSuccessCallback(list);
+          if (checkCurrentDeviceExist && enableAutoCheckoutDevice) {
+            checkCurrentDeviceExist().then((res) => {
+              if (res === false && list?.length > 0) {
+                changeDevicePanel(list[0]);
+              }
+            });
+          }
+        });
+        refreshDeviceListEventCallback && refreshDeviceListEventCallback(event);
+      }
+    );
+    return () => {
+      removeListener2(refreshDeviceListListener);
+      refreshDeviceListListener = null;
+    };
+  }, [refreshDeviceList]);
+  react.useEffect(() => {
+    if (!enableAutoCheckoutDevice) return;
+    if (deviceIsEmpty === true || listIsEmpty === true) {
+      checkoutEmptyPanel();
+    }
+  }, [deviceIsEmpty, listIsEmpty, enableAutoCheckoutDevice]);
+  react.useEffect(() => {
+    if (!enableAutoCheckoutDevice) return;
+    if (device && onceCheckNowDevice) {
+      setOnceCheckNowDevice(false);
+      if (checkCurrentDeviceExist && enableAutoCheckoutDevice) {
+        checkCurrentDeviceExist().then((res) => {
+          if (res === false) {
+            refreshDeviceList && refreshDeviceList((list) => {
+              if (list[0]) {
+                changeDevicePanel(list[0]);
+              }
+            });
+          }
+        });
+      }
+    }
+  }, [device, onceCheckNowDevice, enableAutoCheckoutDevice]);
+};
+var removeListener2 = (listener) => {
+  if (listener) {
+    listener.remove();
+    listener = void 0;
+  }
+};
+var EVENT_TYPE_REFRESH_DEVICE = "QuecRefreshDeviceInfo";
+var refreshDeviceListListener2;
+var panelEventEmitter2 = new reactNative.NativeEventEmitter(reactNative.NativeModules.QuecRNBusinessPanelModule);
+var useInitDeviceInfoUpdateEvent = (refreshDeviceEventCallback) => {
+  const deviceStore2 = getDeviceStoreWithoutError();
+  const deviceStoreState = deviceStore2 ? deviceStore2((state) => state) : null;
+  if (deviceStoreState === null) {
+    deviceKitParamsManager.info(
+      "PS\uFF1A\u5982\u679C\u4F60\u4E0D\u4F7F\u7528\u8BBE\u5907\u5217\u8868\u4FE1\u606F\u72B6\u6001\u7BA1\u7406\uFF0C\u8BF7\u5FFD\u7565\u6B64\u8B66\u544A",
+      "WARNING   \u4F60\u672A\u521D\u59CB\u5316 createDeviceStore "
+    );
+  }
+  const updateDevice = deviceStoreState?.updateDevice ?? null;
+  react.useEffect(() => {
+    removeListener3(refreshDeviceListListener2);
+    refreshDeviceListListener2 = panelEventEmitter2.addListener(
+      EVENT_TYPE_REFRESH_DEVICE,
+      (e) => {
+        deviceKitParamsManager.info(EVENT_TYPE_REFRESH_DEVICE, "\u{1F4DE} ==refresh device info \u{1F504}==");
+        let newDevice = {};
+        try {
+          newDevice = typeof e.device === "string" ? JSON.parse(e.device) : e.device;
+        } catch (error) {
+          deviceKitParamsManager.info(
+            EVENT_TYPE_REFRESH_DEVICE + "  \u{1F4DE} ==refresh device info  get new device info ERROR \u274C==",
+            error
+          );
+        }
+        updateDevice && updateDevice(newDevice);
+        refreshDeviceEventCallback && refreshDeviceEventCallback(e);
+      }
+    );
+    return () => {
+      removeListener3(refreshDeviceListListener2);
+      refreshDeviceListListener2 = null;
+    };
+  }, [updateDevice]);
+};
+var removeListener3 = (listener) => {
+  if (listener) {
+    listener.remove();
+    listener = void 0;
+  }
+};
+var setOfflineReminder = async ({
+  enableOfflineReminder,
+  deviceKey,
+  productKey
+}) => {
+  try {
+    await QuecRNDeviceModule5__default.default.setOfflineReminder(enableOfflineReminder, productKey, deviceKey);
+    deviceKitParamsManager.info("\u{1F50E} QuecRNDeviceModule.setOfflineReminder....", "\u8BBE\u7F6E\u79BB\u7EBF\u63D0\u9192\u5F00\u5173");
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.setOfflineReminder(\u83B7\u53D6\u8BBE\u5907\u72B6\u6001\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+  }
+};
+var getOfflineReminderInfo = async ({
+  productKey,
+  deviceKey
+}) => {
+  try {
+    const result = await QuecRNDeviceModule5__default.default.getOfflineReminderInfo(productKey, deviceKey);
+    deviceKitParamsManager.info("\u{1F50D} QuecRNDeviceModule.getOfflineReminderInfo", result);
+    return +result?.data === 1;
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.getOfflineReminderInfo(\u67E5\u8BE2\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw false;
+  }
+};
+var checkDeviceUpdatePlan = async (device) => {
+  try {
+    await QuecRNDeviceModule5__default.default.checkDeviceUpdatePlan(device);
+    deviceKitParamsManager.info("\u{1F50D} QuecRNDeviceModule.checkDeviceUpdatePlan", "\u6709\u5347\u7EA7\u8BA1\u5212");
+    return true;
+  } catch (error) {
+    deviceKitParamsManager.info("\u{1F50D} QuecRNDeviceModule.checkDeviceUpdatePlan", "\u65E0\u5347\u7EA7\u8BA1\u5212");
+    throw false;
+  }
+};
+var openDeviceOTAPage = async ({
+  productKey,
+  deviceKey
+}) => {
+  try {
+    await QuecRNDeviceModule5__default.default.openDeviceOTAPage(productKey, deviceKey);
+    deviceKitParamsManager.info("\u{1F4C2} QuecRNDeviceModule.openDeviceOTAPage", "\u5DF2\u6253\u5F00\u8BBE\u5907OTA\u8BE6\u60C5\u9875");
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.openDeviceOTAPage(\u6253\u5F00\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+var getTimeDifferenceWithGMT = async () => {
+  try {
+    const result = await QuecRNDeviceModule5__default.default.getTimeDifferenceWithGMT();
+    deviceKitParamsManager.info(
+      "\u{1F552} QuecRNDeviceModule.getTimeDifferenceWithGMT(\u83B7\u53D6\u5F53\u524D\u624B\u673A\u8BBE\u7F6E\u7684\u65F6\u533A\u4E0E GMT \u7684\u5DEE\u503C) ==>",
+      result
+    );
+    return result;
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.getTimeDifferenceWithGMT(\u83B7\u53D6\u5F53\u524D\u624B\u673A\u8BBE\u7F6E\u7684\u65F6\u533A\u4E0E GMT \u7684\u5DEE\u503C\u5931\u8D25)  ==>",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+var getDeviceTimeZone = async ({
+  productKey,
+  deviceKey
+}) => {
+  try {
+    const result = await QuecRNDeviceModule5__default.default.getDeviceTimeZone(productKey, deviceKey);
+    deviceKitParamsManager.info(
+      "\u{1F30D} QuecRNDeviceModule.getDeviceTimeZone(\u83B7\u53D6\u8BBE\u5907\u8BBE\u7F6E\u7684\u65F6\u533A) ==>",
+      result
+    );
+    return result;
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.getDeviceTimeZone(\u83B7\u53D6\u8BBE\u5907\u8BBE\u7F6E\u7684\u65F6\u533A\u5931\u8D25) ==>",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+var setDeviceTimeZone = async ({
+  productKey,
+  deviceKey,
+  timezone
+}) => {
+  try {
+    await QuecRNDeviceModule5__default.default.setDeviceTimeZone(productKey, deviceKey, timezone);
+    deviceKitParamsManager.info(
+      "\u2705 QuecRNDeviceModule.setDeviceTimeZone",
+      `\u5DF2\u8BBE\u7F6E\u65F6\u533A\u4E3A ${timezone}`
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.setDeviceTimeZone(\u8BBE\u7F6E\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+var timeZoneSyncForBleDevice = async ({
+  productKey,
+  deviceKey
+}) => {
+  try {
+    await QuecRNDeviceModule5__default.default.timeZoneSync(productKey, deviceKey);
+    deviceKitParamsManager.info(
+      "\u23F1\uFE0F QuecRNDeviceModule.timeZoneSync",
+      `\u8BBE\u5907\u5DF2\u6821\u65F6\uFF08productKey: ${productKey}, deviceKey: ${deviceKey}\uFF09`
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.timeZoneSync(\u8BBE\u5907\u6821\u65F6\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+var unbindBleDevice = async ({
+  productKey,
+  deviceKey,
+  isInit,
+  random,
+  pureBtResetCredentials
+}) => {
+  try {
+    await QuecRNDeviceModule5__default.default.unbindlingPureBtDevice(
+      productKey,
+      deviceKey,
+      isInit,
+      random,
+      pureBtResetCredentials
+    );
+    deviceKitParamsManager.info(
+      "\u{1F513} QuecRNDeviceModule.unbindlingPureBtDevice",
+      `\u89E3\u7ED1\u6210\u529F\uFF08productKey: ${productKey}, deviceKey: ${deviceKey}\uFF09`
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.unbindlingPureBtDevice(\u89E3\u7ED1\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+var unbindShareDevice = async ({ shareCode }) => {
+  try {
+    await QuecRNDeviceModule5__default.default.unShareDeviceByShareUserWithShareCode(shareCode);
+    deviceKitParamsManager.info(
+      "\u{1F513} QuecRNDeviceModule.unShareDeviceByShareUserWithShareCode",
+      `\u89E3\u7ED1\u6210\u529F\uFF08shareCode: ${shareCode}\uFF09`
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.unShareDeviceByShareUserWithShareCode(\u89E3\u7ED1\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+var unbindDevice = async ({
+  deviceKey,
+  productKey
+}) => {
+  try {
+    await QuecRNDeviceModule5__default.default.unbindDeviceWithDeviceKey(deviceKey, productKey);
+    deviceKitParamsManager.info(
+      "\u{1F513} QuecRNDeviceModule.unbindDeviceWithDeviceKey",
+      `\u89E3\u7ED1\u6210\u529F\uFF08deviceKey: ${deviceKey}, productKey: ${productKey}\uFF09`
+    );
+  } catch (error) {
+    deviceKitParamsManager.error(
+      "\u274C QuecRNDeviceModule.unbindDeviceWithDeviceKey(\u89E3\u7ED1\u5931\u8D25)",
+      "\u5931\u8D25\u539F\u56E0===> " + objToStr(error)
+    );
+    throw error;
+  }
+};
+
+exports.DEVICE_ACCESS_TYPE_DIRECTLY = DEVICE_ACCESS_TYPE_DIRECTLY;
+exports.DEVICE_ACCESS_TYPE_GATEWAY = DEVICE_ACCESS_TYPE_GATEWAY;
+exports.DEVICE_ACCESS_TYPE_GATEWAY_CHILD = DEVICE_ACCESS_TYPE_GATEWAY_CHILD;
+exports.DEVICE_NAME_MAX_LENGTH = DEVICE_NAME_MAX_LENGTH;
+exports.DEVICE_TYPE_BIND = DEVICE_TYPE_BIND;
+exports.DEVICE_TYPE_SHARE = DEVICE_TYPE_SHARE;
+exports.EVENT_TYPE_DEVICE_CONNECTING = EVENT_TYPE_DEVICE_CONNECTING;
+exports.EVENT_TYPE_DEVICE_ONLINE = EVENT_TYPE_DEVICE_ONLINE;
+exports.EVENT_TYPE_REFRESH_DEVICE = EVENT_TYPE_REFRESH_DEVICE;
+exports.EVENT_TYPE_REFRESH_DEVICE_LIST = EVENT_TYPE_REFRESH_DEVICE_LIST;
+exports.LOADING_SEND_TIMEOUT = LOADING_SEND_TIMEOUT;
+exports.NOT_CONNECTING = NOT_CONNECTING;
+exports.changeDevicePanel = changeDevicePanel;
+exports.checkDeviceUpdatePlan = checkDeviceUpdatePlan;
+exports.checkoutEmptyPanel = checkoutEmptyPanel;
+exports.connectChannel = connectChannel;
+exports.createDeviceListStore = createDeviceListStore;
+exports.createDeviceStore = createDeviceStore;
+exports.deviceKitParamsManager = deviceKitParamsManager;
+exports.disconnectChannel = disconnectChannel;
+exports.getDeviceConnectingState = getDeviceConnectingState;
+exports.getDeviceListStore = getDeviceListStore;
+exports.getDeviceListStoreWithoutError = getDeviceListStoreWithoutError;
+exports.getDeviceOnlineState = getDeviceOnlineState;
+exports.getDeviceStore = getDeviceStore;
+exports.getDeviceStoreWithoutError = getDeviceStoreWithoutError;
+exports.getDeviceTimeZone = getDeviceTimeZone;
+exports.getOfflineReminderInfo = getOfflineReminderInfo;
+exports.getProductDescription = getProductDescription;
+exports.getTimeDifferenceWithGMT = getTimeDifferenceWithGMT;
+exports.onlineStatus = onlineStatus;
+exports.openDeviceOTAPage = openDeviceOTAPage;
+exports.setDeviceTimeZone = setDeviceTimeZone;
+exports.setOfflineReminder = setOfflineReminder;
+exports.timeZoneSyncForBleDevice = timeZoneSyncForBleDevice;
+exports.unbindBleDevice = unbindBleDevice;
+exports.unbindDevice = unbindDevice;
+exports.unbindShareDevice = unbindShareDevice;
+exports.useCheckCurrentDeviceExist = useCheckCurrentDeviceExist;
+exports.useDevice = useDevice;
+exports.useDeviceArea = useDeviceArea;
+exports.useDeviceBleOnline = useDeviceBleOnline;
+exports.useDeviceFamily = useDeviceFamily;
+exports.useDeviceIsConnecting = useDeviceIsConnecting;
+exports.useDeviceIsOnlyBle = useDeviceIsOnlyBle;
+exports.useDeviceLanOnline = useDeviceLanOnline;
+exports.useDeviceList = useDeviceList;
+exports.useDeviceListLoadMore = useDeviceListLoadMore;
+exports.useDeviceListRefresh = useDeviceListRefresh;
+exports.useDeviceListStoreState = useDeviceListStoreState;
+exports.useDeviceOnline = useDeviceOnline;
+exports.useDeviceProductUrl = useDeviceProductUrl;
+exports.useDeviceProps = useDeviceProps;
+exports.useDeviceState = useDeviceState;
+exports.useDeviceStoreState = useDeviceStoreState;
+exports.useDeviceWsOnline = useDeviceWsOnline;
+exports.useEndUserId = useEndUserId;
+exports.useGetDeviceStatus = useGetDeviceStatus;
+exports.useInitDeviceInfoUpdateEvent = useInitDeviceInfoUpdateEvent;
+exports.useInitDeviceListUpdateEvent = useInitDeviceListUpdateEvent;
+exports.useInitUpdateDeviceStateEvent = useInitUpdateDeviceStateEvent;
+exports.useSetProps = useSetProps;
+exports.useUpdateDevice = useUpdateDevice;
+exports.useUpdateDeviceConnectingState = useUpdateDeviceConnectingState;
+exports.useUpdateDeviceName = useUpdateDeviceName;
+exports.useUpdateOnlineStatus = useUpdateOnlineStatus;
+exports.useUserAccount = useUserAccount;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map