@ray-js/lock-sdk 1.0.1 → 1.0.3-beta-1

package/lib/other.js

@@ -1,6 +1,3 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-const _excluded = ["themeColor"];
 import dpUtils from "@ray-js/tuya-dp-transform";
 import config from "./config";
 import dpCodes from "./config/dp-code";
@@ -9,170 +6,121 @@ import { getDpValue } from "./state";
 import { openPanel } from "./utils/device";
 import { getError } from "./utils/errors";
 import { publishDps } from "./utils/publishDps";
-const {
-  alarmLock,
-  unlockFingerprint,
-  unlockPassword,
-  unlockCard,
-  unlockKey,
-  unlockPhoneRemote
-} = dpCodes;
-
-/**
- * 打开场景
- * @param options - 打开场景的参数
- * @param options.themeColor - 主题颜色
- */
-export const openScene = async options => {
-  const dpIds = [unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote].reduce((acc, item) => {
-    const id = config.idsByCode[item];
-    if (id) {
-      acc.push(id);
-    }
-    return acc;
-  }, []);
-  const _ref = options || {},
-    {
-      themeColor = ""
-    } = _ref,
-    res = _objectWithoutProperties(_ref, _excluded);
-  return new Promise((resolve, reject) => {
-    openPanel({
-      deviceId: config.devInfo.devId,
-      extraInfo: {
-        productId: config.devInfo.productId,
-        bizClientId: "tyqawbz9jf6oqvynya",
-        productVersion: "1.0.0",
-        i18nTime: "12344",
-        uiType: "SMART_MINIPG"
-      },
-      initialProps: _objectSpread({
-        openDpLists: dpIds.join(","),
-        dpCode: alarmLock,
-        themeColor
-      }, res),
-      success: resolve,
-      fail: reject
+const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, } = dpCodes;
+const abilityMap = {
+    backHome: "supportBackHome",
+    alarm: "supportAlarm",
+};
+export const openScene = async (options) => {
+    const dpIds = [
+        unlockFingerprint,
+        unlockPassword,
+        unlockCard,
+        unlockKey,
+        unlockPhoneRemote,
+    ].reduce((acc, item) => {
+        const id = config.idsByCode[item];
+        if (id) {
+            acc.push(id);
+        }
+        return acc;
+    }, []);
+    const { themeColor = "#ff592a", executorRange = ["unlock", "lock"], abilities = [], } = options || {};
+    return new Promise((resolve, reject) => {
+        openPanel({
+            deviceId: config.devInfo.devId,
+            extraInfo: {
+                productId: config.devInfo.productId,
+                bizClientId: "tyqawbz9jf6oqvynya",
+                productVersion: "1.0.0",
+                i18nTime: "12344",
+                uiType: "SMART_MINIPG",
+            },
+            initialProps: {
+                openDpLists: dpIds.join(","),
+                dpCode: alarmLock,
+                themeColor,
+                withConfig: {
+                    powerCode: {
+                        tyabihqarm: abilities.map((ability) => abilityMap[ability] || ability),
+                        tyabixjkg8: executorRange,
+                    },
+                },
+            },
+            success: resolve,
+            fail: reject,
+        });
     });
-  });
 };
-
-/**
- * 判断是否支持蓝牙控制
- * @returns boolean
- */
 export const isSupportBleControl = () => {
-  const {
-    devInfo,
-    codesById,
-    communication
-  } = config;
-  if (!codesById[dpCodes.unlockBle]) {
-    return false;
-  }
-
-  // 如果是 matter 设备，则判断是否有激活蓝牙
-  // 获取是否连云激活
-  const hasThread = communication.includes(ProductCommunicationType.THREAD);
-  const hasWifi = communication.includes(ProductCommunicationType.WIFI);
-  const hasBle = communication.includes(ProductCommunicationType.BLUETOOTH);
-  // 通讯能力不支持蓝牙时，不支持蓝牙控制
-  if (!hasBle) {
-    return false;
-  }
-  if (hasThread) {
-    var _devInfo$meta;
-    // 仅支持 Matter + BLE，当元数据里无 threadWithBLE 此标记时，表示蓝牙未激活
-    if (!(devInfo !== null && devInfo !== void 0 && (_devInfo$meta = devInfo.meta) !== null && _devInfo$meta !== void 0 && _devInfo$meta["threadWithBLE"])) {
-      return false;
+    const { devInfo, codesById, communication } = config;
+    if (!codesById[dpCodes.unlockBle]) {
+        return false;
+    }
+    const hasThread = communication.includes(ProductCommunicationType.THREAD);
+    const hasWifi = communication.includes(ProductCommunicationType.WIFI);
+    const hasBle = communication.includes(ProductCommunicationType.BLUETOOTH);
+    if (!hasBle) {
+        return false;
+    }
+    if (hasThread) {
+        if (!devInfo?.meta?.["threadWithBLE"]) {
+            return false;
+        }
     }
-  }
-  // 双模设备下，如果未激活 Wifi，则都可以支持蓝牙控制
-  if (hasWifi && hasBle) {
-    if (devInfo.wifiEnableState === 1) {
-      return true;
+    if (hasWifi && hasBle) {
+        if (devInfo.wifiEnableState === 1) {
+            return true;
+        }
     }
-  }
-
-  // 存在 dp 42(蓝牙模块开启开关)，当 dp42 为 true 时，表示蓝牙模块已开启，则支持蓝牙控制
-  const bleControlDp = codesById[dpCodes.bleControl];
-  if (bleControlDp) {
-    var _devInfo$dpsTime;
-    // // 边界判断，是否有上报时间
-    const reportTIme = devInfo === null || devInfo === void 0 || (_devInfo$dpsTime = devInfo.dpsTime) === null || _devInfo$dpsTime === void 0 ? void 0 : _devInfo$dpsTime[bleControlDp];
-    const hasReportTime = !reportTIme || Math.floor(Number(reportTIme) / 1000) <= devInfo.activeTime;
-    if (!getDpValue(dpCodes.bleControl) || !hasReportTime) {
-      return true;
+    const bleControlDp = codesById[dpCodes.bleControl];
+    if (bleControlDp) {
+        const reportTIme = devInfo?.dpsTime?.[bleControlDp];
+        const hasReportTime = !reportTIme ||
+            Math.floor(Number(reportTIme) / 1000) <= devInfo.activeTime;
+        if (!getDpValue(dpCodes.bleControl) || !hasReportTime) {
+            return true;
+        }
+        return getDpValue(dpCodes.bleControl);
     }
-    return getDpValue(dpCodes.bleControl);
-  }
-  return true;
+    return true;
 };
-const periodDpMap = [{
-  name: "startHour"
-}, {
-  name: "startMinute"
-}, {
-  name: "endHour"
-}, {
-  name: "endMinute"
-}];
-
-/**
- * 获取休眠时间段
- * @param dpCode - 待获取时段的 dp
- * @returns 返回时间段
- * start: 开始时间（分钟）
- * end: 结束时间（分钟）
- */
-export const getDpPeriodTime = dpCode => {
-  const {
-    dpSchema
-  } = config;
-  const dpValue = getDpValue(dpCode);
-  if (typeof dpSchema[dpCode] !== "undefined" && dpValue) {
-    var _data$startHour, _data$startMinute, _data$endHour, _data$endMinute;
-    const data = dpUtils.parse(getDpValue(dpCodes.dormantTimeSet),
-    // @ts-expect-error
-    periodDpMap);
+const periodDpMap = [
+    { name: "startHour" },
+    { name: "startMinute" },
+    { name: "endHour" },
+    { name: "endMinute" },
+];
+export const getDpPeriodTime = (dpCode) => {
+    const { dpSchema } = config;
+    const dpValue = getDpValue(dpCode);
+    if (typeof dpSchema[dpCode] !== "undefined" && dpValue) {
+        const data = dpUtils.parse(getDpValue(dpCodes.dormantTimeSet), periodDpMap);
+        return {
+            start: (data.startHour ?? 0) * 60 + (data.startMinute ?? 0),
+            end: (data.endHour ?? 0) * 60 + (data.endMinute ?? 0),
+        };
+    }
     return {
-      start: ((_data$startHour = data.startHour) !== null && _data$startHour !== void 0 ? _data$startHour : 0) * 60 + ((_data$startMinute = data.startMinute) !== null && _data$startMinute !== void 0 ? _data$startMinute : 0),
-      end: ((_data$endHour = data.endHour) !== null && _data$endHour !== void 0 ? _data$endHour : 0) * 60 + ((_data$endMinute = data.endMinute) !== null && _data$endMinute !== void 0 ? _data$endMinute : 0)
+        start: 0,
+        end: 0,
     };
-  }
-  return {
-    start: 0,
-    end: 0
-  };
 };
-
-/**
- * 设置时间段
- * @param dpCode - 待设置时段的 dp
- * @param params 休眠时间段数据
- * start: 开始时间（分钟）
- * end: 结束时间（分钟）
- * @returns Promise<void>
- */
 export const updateDpPeriodTime = (dpCode, data) => {
-  const {
-    dpSchema
-  } = config;
-  if (typeof dpSchema[dpCode] === "undefined") {
-    throw getError(1014);
-  }
-  const startHour = Math.floor(data.start / 60);
-  const startMinute = data.start % 60;
-  const endHour = Math.floor(data.end / 60);
-  const endMinute = data.end % 60;
-  return publishDps({
-    dormant_time_set: dpUtils.format({
-      startHour,
-      startMinute,
-      endHour,
-      endMinute
-    },
-    // @ts-expect-error
-    periodDpMap)
-  });
-};
+    const { dpSchema } = config;
+    if (typeof dpSchema[dpCode] === "undefined") {
+        throw getError(1014);
+    }
+    const startHour = Math.floor(data.start / 60);
+    const startMinute = data.start % 60;
+    const endHour = Math.floor(data.end / 60);
+    const endMinute = data.end % 60;
+    return publishDps({
+        dormant_time_set: dpUtils.format({
+            startHour,
+            startMinute,
+            endHour,
+            endMinute,
+        }, periodDpMap),
+    });
+};

package/lib/parse/index.d.ts

@@ -1,6 +1,2 @@
 import { CapabilityInfo } from "../interface";
-/**
- * 解析设备能力
- * @param dpValue
- */
 export declare const parseCapabilities: (dpValue: string) => CapabilityInfo | null;

package/lib/parse/index.js

@@ -1,22 +1,16 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { capabilities as capabilitiesMap } from "../config/dp-map/normal";
 import { ModuleType } from "../constant";
-
-/**
- * 解析设备能力
- * @param dpValue
- */
-export const parseCapabilities = dpValue => {
-  if (!dpValue) {
-    return null;
-  }
-  const data = dpUtils.parse(dpValue, capabilitiesMap);
-  if (data.tyep === ModuleType.M7258) {
-    // 针对 7258 模组，处理旋转方式，1和0互换
-    return _objectSpread(_objectSpread({}, data), {}, {
-      rotateType: data.rotateType === 1 ? 0 : data.rotateType === 0 ? 1 : data.rotateType
-    });
-  }
-  return data;
-};
+export const parseCapabilities = (dpValue) => {
+    if (!dpValue) {
+        return null;
+    }
+    const data = dpUtils.parse(dpValue, capabilitiesMap);
+    if (data.tyep === ModuleType.M7258) {
+        return {
+            ...data,
+            rotateType: data.rotateType === 1 ? 0 : data.rotateType === 0 ? 1 : data.rotateType,
+        };
+    }
+    return data;
+};

package/lib/signal.d.ts

@@ -1,8 +1,3 @@
-/**
- * 获取设备信号强度
- * 此方法只向设备触发动作不返回信号强度，信号强度变化通过 onSignalChange 监听
- * @returns
- */
 export declare const getWiFiSignal: () => Promise<{
     fetchedData: Record<string, {
         fetchedData: any;
@@ -13,14 +8,6 @@ type WiFiSignalChangeListener = (params: {
     signal: number;
     level: "good" | "normal" | "weak" | "bad";
 }) => void;
-/**
- * 监听设备信号强度变化
- * @returns
- */
 export declare const onWiFiSignalChange: (cb: WiFiSignalChangeListener) => void;
-/**
- * 监听设备信号强度变化
- * @returns
- */
 export declare const offWiFiSignalChange: (cb: WiFiSignalChangeListener) => void;
 export {};

package/lib/signal.js

@@ -2,37 +2,23 @@ import config from "./config";
 import { sendMqttMessage } from "./utils/device";
 import { getError } from "./utils/errors";
 import emitter from "./utils/event";
-
-/**
- * 获取设备信号强度
- * 此方法只向设备触发动作不返回信号强度，信号强度变化通过 onSignalChange 监听
- * @returns
- */
 export const getWiFiSignal = () => {
-  if (config.devInfo.isCloudOnline) {
-    return sendMqttMessage({
-      deviceId: config.devInfo.devId,
-      protocol: 22,
-      message: {
-        reqType: "sigQry"
-      }
-    });
-  } else {
-    throw getError(1001);
-  }
+    if (config.devInfo.isCloudOnline) {
+        return sendMqttMessage({
+            deviceId: config.devInfo.devId,
+            protocol: 22,
+            message: {
+                reqType: "sigQry",
+            },
+        });
+    }
+    else {
+        throw getError(1001);
+    }
 };
-/**
- * 监听设备信号强度变化
- * @returns
- */
-export const onWiFiSignalChange = cb => {
-  emitter.on("onWiFiSignalChange", cb);
+export const onWiFiSignalChange = (cb) => {
+    emitter.on("onWiFiSignalChange", cb);
+};
+export const offWiFiSignalChange = (cb) => {
+    emitter.off("onWiFiSignalChange", cb);
 };
-
-/**
- * 监听设备信号强度变化
- * @returns
- */
-export const offWiFiSignalChange = cb => {
-  emitter.off("onWiFiSignalChange", cb);
-};

package/lib/sleep.d.ts

@@ -1,61 +1,19 @@
-/**
- * 判断锁是否处于休眠状态
- * @returns true 表示为休眠中
- */
 export declare const isSleep: () => boolean;
-/**
- * 判断锁是否支持休眠功能
- * @returns true 表示支持休眠功能
- */
 export declare const hasSleepAbility: () => boolean;
-/**
- * 判断休眠功能是否已启用
- * @returns true 表示休眠功能已启用
- * false 表示休眠功能已禁用
- */
 export declare const isEnabledSleep: () => import("./interface").DpValue;
-/**
- * 启用休眠
- * @returns Promise<void>
- */
 export declare const enableSleep: () => Promise<Record<string, import("./interface").DpValue>>;
-/**
- * 禁用休眠
- * @returns Promise<void>
- */
 export declare const disableSleep: () => Promise<Record<string, import("./interface").DpValue>>;
-/**
- * 获取休眠时间段
- * @returns 返回休眠时间段
- * start: 开始时间（分钟）
- * end: 结束时间（分钟）
- */
 export declare const getSleepPeriod: () => {
     start: number;
     end: number;
 };
-/**
- * 设置休眠时间段
- * @param params 休眠时间段
- * startTime: 开始时间（分钟）
- * endTime: 结束时间（分钟）
- * @returns Promise<void>
- */
 export declare const updateSleepPeriod: (params: {
     start: number;
     end: number;
 }) => Promise<Record<string, import("./interface").DpValue>>;
-/**
- * 注册休眠状态变更事件
- * @param callback 休眠状态变更回调
- */
 export declare const onSleepStatusChange: (callback: (args: {
     sleep: boolean;
 }) => void) => void;
-/**
- * 注销休眠状态变更事件
- * @param callback 休眠状态变更回调
- */
 export declare const offSleepStatusChange: (callback: (args: {
     sleep: boolean;
 }) => void) => void;

package/lib/sleep.js

@@ -6,116 +6,59 @@ import emitter from "./utils/event";
 import { SLEEP_EVENT } from "./event";
 import dpCodes from "./config/dp-code";
 import { getDpPeriodTime, updateDpPeriodTime } from "./other";
-
-/**
- * 判断锁是否处于休眠状态
- * @returns true 表示为休眠中
- */
 export const isSleep = () => {
-  const {
-    dpSchema
-  } = config;
-  if (typeof dpSchema[dpCodes.linkMode] === "undefined") {
-    return false;
-  }
-  const linkMode = getDpValue(dpCodes.linkMode);
-  return linkMode === "sleep" || linkMode === "lock_sleep";
+    const { dpSchema } = config;
+    if (typeof dpSchema[dpCodes.linkMode] === "undefined") {
+        return false;
+    }
+    const linkMode = getDpValue(dpCodes.linkMode);
+    return linkMode === "sleep" || linkMode === "lock_sleep";
 };
-
-/**
- * 判断锁是否支持休眠功能
- * @returns true 表示支持休眠功能
- */
 export const hasSleepAbility = () => {
-  const {
-    dpSchema
-  } = config;
-  return (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined" || typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") && typeof dpSchema[dpCodes.dormantTimeSet] !== "undefined";
+    const { dpSchema } = config;
+    return ((typeof dpSchema[dpCodes.dormantSwitch] !== "undefined" ||
+        typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") &&
+        typeof dpSchema[dpCodes.dormantTimeSet] !== "undefined");
 };
-const setSleepStatus = async status => {
-  const {
-    dpSchema
-  } = config;
-  if (typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") {
-    return publishDps({
-      [dpCodes.onlineSwitch]: status
-    });
-  }
-  if (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined") {
-    return publishDps({
-      [dpCodes.dormantSwitch]: status
-    });
-  }
-  throw getError(1014);
+const setSleepStatus = async (status) => {
+    const { dpSchema } = config;
+    if (typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") {
+        return publishDps({
+            [dpCodes.onlineSwitch]: status,
+        });
+    }
+    if (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined") {
+        return publishDps({
+            [dpCodes.dormantSwitch]: status,
+        });
+    }
+    throw getError(1014);
 };
-
-/**
- * 判断休眠功能是否已启用
- * @returns true 表示休眠功能已启用
- * false 表示休眠功能已禁用
- */
 export const isEnabledSleep = () => {
-  const {
-    dpSchema
-  } = config;
-  if (typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") {
-    return getDpValue(dpCodes.onlineSwitch);
-  }
-  if (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined") {
-    return getDpValue(dpCodes.dormantSwitch);
-  }
-  throw getError(1014);
+    const { dpSchema } = config;
+    if (typeof dpSchema[dpCodes.onlineSwitch] !== "undefined") {
+        return getDpValue(dpCodes.onlineSwitch);
+    }
+    if (typeof dpSchema[dpCodes.dormantSwitch] !== "undefined") {
+        return getDpValue(dpCodes.dormantSwitch);
+    }
+    throw getError(1014);
 };
-
-/**
- * 启用休眠
- * @returns Promise<void>
- */
 export const enableSleep = async () => {
-  return setSleepStatus(true);
+    return setSleepStatus(true);
 };
-
-/**
- * 禁用休眠
- * @returns Promise<void>
- */
 export const disableSleep = async () => {
-  return setSleepStatus(false);
+    return setSleepStatus(false);
 };
-
-/**
- * 获取休眠时间段
- * @returns 返回休眠时间段
- * start: 开始时间（分钟）
- * end: 结束时间（分钟）
- */
 export const getSleepPeriod = () => {
-  return getDpPeriodTime(dpCodes.dormantTimeSet);
+    return getDpPeriodTime(dpCodes.dormantTimeSet);
 };
-
-/**
- * 设置休眠时间段
- * @param params 休眠时间段
- * startTime: 开始时间（分钟）
- * endTime: 结束时间（分钟）
- * @returns Promise<void>
- */
-export const updateSleepPeriod = params => {
-  return updateDpPeriodTime(dpCodes.dormantTimeSet, params);
+export const updateSleepPeriod = (params) => {
+    return updateDpPeriodTime(dpCodes.dormantTimeSet, params);
 };
-
-/**
- * 注册休眠状态变更事件
- * @param callback 休眠状态变更回调
- */
-export const onSleepStatusChange = callback => {
-  emitter.on(SLEEP_EVENT, callback);
+export const onSleepStatusChange = (callback) => {
+    emitter.on(SLEEP_EVENT, callback);
+};
+export const offSleepStatusChange = (callback) => {
+    emitter.off(SLEEP_EVENT, callback);
 };
-
-/**
- * 注销休眠状态变更事件
- * @param callback 休眠状态变更回调
- */
-export const offSleepStatusChange = callback => {
-  emitter.off(SLEEP_EVENT, callback);
-};