@ray-js/lock-sdk 1.0.0-beta-1

package/lib/utils/index.js

@@ -0,0 +1,419 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.js";
+import config from "../config";
+import dpCodes from "../config/dp-code";
+import { ProductCommunicationType } from "../constant";
+import { LoopTypes } from "./constant";
+import { getBackgroundFetchData, getCurrentHomeInfo, onBackgroundFetchData } from "./device";
+import { getError } from "./errors";
+
+/**
+ * 格式化为24时间格式
+ * @param time
+ * @returns
+ */
+export const get24Time = time => {
+  const hours = Math.floor(time / 60);
+  return [hours, time % 60];
+};
+export const getNowTime = () => {
+  const now = new Date();
+  return now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds();
+};
+
+/**
+ * 判断设备在线类型
+ * @param onlineType 设备的通道在线数据
+ * @param type 待检测的通道类型，0为wifi，1为局域网，2为蓝牙，3为Mesh,  4为 beacon
+ * @returns
+ */
+export const isOnlineByType = (onlineType, type) => {
+  // eslint-disable-next-line no-bitwise
+  return (onlineType & 2 ** type) >> type === 1;
+};
+
+// 遍历capability类型，通讯类型
+const supportCapabilities = [{
+  id: 0,
+  name: "wifi",
+  short: "wf"
+}, {
+  id: 1,
+  name: "cable",
+  short: "ca"
+}, {
+  id: 2,
+  name: "gprs",
+  short: "gp"
+}, {
+  id: 3,
+  name: "nb-iot",
+  short: "nb"
+}, {
+  id: 10,
+  name: "bluetooth",
+  short: "ble"
+}, {
+  id: 11,
+  name: "blemesh",
+  short: "bm"
+}, {
+  id: 12,
+  name: "zigbee",
+  short: "zig"
+}, {
+  id: 13,
+  name: "infrared",
+  short: "inf"
+}, {
+  id: 14,
+  name: "subpieces",
+  short: "sub"
+}, {
+  id: 15,
+  name: "sigmesh",
+  short: "sig"
+}, {
+  id: 16,
+  name: "mcu",
+  short: "mcu"
+}, {
+  id: 17,
+  name: "ty_smesh",
+  short: "TY_SMESH"
+}, {
+  id: 18,
+  name: "Zwave",
+  short: "Zwave"
+}, {
+  id: 19,
+  name: "pl-mesh",
+  short: "pl-mesh"
+}, {
+  id: 20,
+  name: "cat1",
+  short: "cat1"
+}, {
+  id: 21,
+  name: "beacon",
+  short: "beacon"
+}, {
+  id: 22,
+  name: "cat4",
+  short: "cat4"
+}, {
+  id: 23,
+  name: "cat10",
+  short: "cat10"
+}, {
+  id: 24,
+  name: "lte-catm",
+  short: "catm"
+}, {
+  id: 25,
+  name: "thread",
+  short: "thread"
+}];
+export function isCapability(capability, id) {
+  const redId = 1 << id;
+  return (capability & redId) === redId;
+}
+
+/**
+ * 获取产品支持的通讯能力
+ * @param capability 产品能力值
+ * @returns
+ */
+export function getCapabilities(capability) {
+  return supportCapabilities.filter(item => {
+    return isCapability(capability, item.id);
+  });
+}
+
+// 格式化周
+export const formatWeek = value => {
+  return parseInt([...value].reverse().join(""), 2);
+};
+
+// 格式化周
+export const parseWeek = value => {
+  return Number(value).toString(2).padStart(7, "0").split("").reverse().map(Number).slice(0, 7);
+};
+
+/**
+ * 获取一个永久生效的设置
+ * @returns
+ */
+export const getPermanentSetting = () => {
+  const now = Math.floor(+new Date() / 1000);
+  return {
+    startTime: now,
+    // 如果是永久生效，则设置为 100 年后失效
+    endTime: now + 3153600000,
+    loop: LoopTypes.NONE,
+    loopConfig: 0,
+    weeks: [0, 0, 0, 0, 0, 0, 0],
+    days: [],
+    startHour: 0,
+    startMinute: 0,
+    endHour: 0,
+    endMinute: 0
+  };
+};
+export const isAdmin = userType => userType === 10 || userType === 50 ? true : false;
+export const validateEffectiveConfig = effective => {
+  if (!effective) {
+    // 不是永久生效时，需要传入生效时间配置
+    throw getError(1032);
+  }
+  // 生效时间段判断
+  if (!effective.effectiveDate) {
+    throw getError(1033);
+  }
+  if (!effective.expiredDate) {
+    throw getError(1034);
+  }
+  if (+effective.effectiveDate > +effective.expiredDate) {
+    throw getError(1010);
+  }
+  switch (effective.repeat) {
+    case "week":
+      if (!effective.weeks) {
+        throw getError(1035);
+      }
+      break;
+    // case "month":
+    //   if (!effective.days) {
+    //     throw getError(1036);
+    //   }
+    //   break;
+    // default:
+  }
+};
+
+/**
+ * 是否使用近场通道，一般为蓝牙
+ * @returns
+ */
+export const isUseNearChannel = () => {
+  const {
+    onlineType,
+    devInfo,
+    communication
+  } = config;
+  const isBleOnline = isOnlineByType(onlineType, 2);
+  const isSupportWifi = communication.includes(ProductCommunicationType.WIFI);
+  const isSupportBle = communication.includes(ProductCommunicationType.BLUETOOTH);
+  const isSupportThread = communication.includes(ProductCommunicationType.THREAD);
+  // wifi + ble 双模
+  if (isSupportWifi && isSupportBle) {
+    return isBleOnline;
+  }
+  // thread + ble 双模
+  if (isSupportThread && isSupportBle) {
+    return isBleOnline && !devInfo.isCloudOnline && !devInfo.isLocalOnline;
+  }
+  return isBleOnline;
+};
+export const parseOfflinePassword = value => {
+  if (config.passwordDigitalBase === 10) {
+    // 10进制时，直接显示
+    return value;
+  }
+  // 其他进制时，转换后显示
+  let digitalCode = Number(value).toString(config.passwordDigitalBase);
+  // 补0
+  const zeroList = value.match(/(^0+)/);
+  if (zeroList) {
+    digitalCode = zeroList[0] + digitalCode;
+  }
+  // 是否隐藏0
+  if (config.passwordSupportZero === false) {
+    digitalCode = digitalCode.split("").map(n => {
+      return Number(n) + 1;
+    }).join("");
+  }
+  return digitalCode;
+};
+
+/**
+ * 格式化时间戳为毫秒
+ * 注意此方法只支持 2010 年之后的时间戳
+ * @param timestamp 时间戳
+ */
+export const formatTimestampToMilliseconds = timestamp => {
+  const isMilliseconds = timestamp.toString().length >= 13;
+  return isMilliseconds ? timestamp : timestamp * 1000;
+};
+
+/**
+ * 开锁方式配置数据
+ */
+export const unlockMethodConfigs = [{
+  type: "password",
+  code: dpCodes.unlockPassword,
+  id: 1
+}, {
+  type: "card",
+  code: dpCodes.unlockCard,
+  id: 2
+}, {
+  type: "finger",
+  code: dpCodes.unlockFingerprint,
+  id: 3
+}, {
+  type: "face",
+  code: dpCodes.unlockFace,
+  id: 4
+}, {
+  type: "hand",
+  code: dpCodes.unlockHand,
+  id: 5
+}, {
+  type: "fingerVein",
+  code: dpCodes.unlockFingerVein,
+  id: 6
+}];
+const getUnlockMethodType = cb => {
+  const result = unlockMethodConfigs.find(cb);
+  // 有此方式且设备是否支持此能力
+  if (result && config.dpSchema[result.code]) {
+    return result;
+  }
+  throw getError(1014);
+};
+export const getUnlockMethodTypeByDpCode = dpCode => {
+  return getUnlockMethodType(item => item.code === dpCode);
+};
+export const getUnlockMethodTypeById = id => {
+  return getUnlockMethodType(item => item.id === id);
+};
+export const getUnlockMethodTypeByType = type => {
+  return getUnlockMethodType(item => item.type === type);
+};
+let cbIndex = 0;
+const cbMap = {};
+/**
+ * 针对异常函数，当函数在短时间内被多次调用时，只保留最先一次调用，并统一返回结果
+ * @param cb 回调函数
+ * @returns
+ */
+export const parallelMerge = cb => {
+  let isRuning = false;
+  let cbId = cbIndex++;
+  // @ts-expect-error
+  return async function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    const key = JSON.stringify(args);
+    // 如果正在执行，则直接抛错
+    if (isRuning) {
+      // 暂存回调
+      if (!cbMap[cbId]) {
+        cbMap[cbId] = {};
+      }
+      if (!cbMap[cbId][key]) {
+        cbMap[cbId][key] = [];
+      }
+      return new Promise((resolve, reject) => {
+        cbMap[cbId][key].push({
+          resolve,
+          reject
+        });
+      });
+    }
+    isRuning = true;
+    try {
+      const result = await cb(...args);
+      isRuning = false;
+      // 如果是 merge 模式，执行所有暂存的回调
+      if (cbMap[cbId] && cbMap[cbId][key]) {
+        let list = cbMap[cbId][key];
+        delete cbMap[cbId][key]; // 删除已处理的回调
+        setTimeout(() => {
+          list.forEach(item => item.resolve(result));
+        }, 0);
+      }
+      return result;
+    } catch (error) {
+      isRuning = false;
+      // 如果是 merge 模式，执行所有暂存的回调
+      if (cbMap[cbId] && cbMap[cbId][key]) {
+        let list = cbMap[cbId][key];
+        delete cbMap[cbId][key]; // 删除已处理的回调
+        setTimeout(() => {
+          list.forEach(item => item.reject(error));
+        }, 0);
+      }
+      throw error;
+    }
+  };
+};
+
+/**
+ * 针对异常函数，当函数在短时间内被多次调用时，只允许函数在短时间内执行一次
+ * @param cb 回调函数
+ * @returns
+ */
+export const parallelOnly = cb => {
+  let isRuning = false;
+  cbIndex++; // @ts-expect-error
+  return async function () {
+    // 如果正在执行，则直接抛错
+    if (isRuning) {
+      throw getError(1052);
+    }
+    isRuning = true;
+    try {
+      const result = await cb(...arguments);
+      isRuning = false;
+      return result;
+    } catch (error) {
+      isRuning = false;
+      throw error;
+    }
+  };
+};
+const preFetchKeys = ["getRotate", "getCurrentUser", "getDeviceProperties"];
+/**
+ * 预加载数据处理
+ */
+const preFetchData = {};
+// @ts-expect-error
+onBackgroundFetchData(preFetchKeys, res => {
+  var _res$fetchedData;
+  Object.keys((_res$fetchedData = res === null || res === void 0 ? void 0 : res.fetchedData) !== null && _res$fetchedData !== void 0 ? _res$fetchedData : {}).forEach(key => {
+    preFetchData[key] = res.fetchedData[key].fetchedData;
+  });
+});
+export const getDataWithPreFetch = async (key, apiCb) => {
+  if (preFetchData[key]) {
+    return preFetchData[key];
+  }
+  try {
+    const result = await getBackgroundFetchData([key]);
+    if (result && result.fetchedData[key] && result.fetchedData[key].fetchedData) {
+      // 有数据时，则返回数据，无数据则执行接口调用
+      return result.fetchedData[key].fetchedData;
+    }
+  } catch {
+    //
+  }
+  return apiCb();
+};
+export const equels = (source, target) => {
+  return JSON.stringify(source) === JSON.stringify(target);
+};
+export const sleep = ms => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+let homeInfo = null;
+export const getHomeInfo = async () => {
+  if (homeInfo) {
+    return homeInfo;
+  }
+  homeInfo = await getCurrentHomeInfo();
+  return homeInfo;
+};

package/lib/utils/log.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 处理日志数据
+ */
+import { LocalOperateData, LocalOperateRecordInfo } from "../interface";
+export declare const handleLocalOperation: (log?: LocalOperateRecordInfo) => LocalOperateData | undefined;

package/lib/utils/log.js

@@ -0,0 +1,78 @@
+/**
+ * 处理日志数据
+ */
+
+import { LocalOperateCategory } from "../constant";
+import { bytesToUint } from "./byte";
+import hexToBytes from "./hex-to-bytes";
+const localRecordUnlock = [LocalOperateCategory.ADD_UNLOCK_METHOD, LocalOperateCategory.DELETE_UNLOCK_METHOD, LocalOperateCategory.MODIFY_UNLOCK_METHOD];
+const localRecordUserOperate = [LocalOperateCategory.ADD_USER, LocalOperateCategory.DELETE_USER];
+const unlockMethodMap = ["finger", "face", "password", "card", "fingerVein", "hand", "eye", "remoteControl"];
+export const handleLocalOperation = log => {
+  if (!log) {
+    return;
+  }
+  const {
+    operClassify,
+    userId,
+    userType,
+    operType,
+    operDetail,
+    toUserType,
+    toUserId
+  } = log;
+  const data = hexToBytes(operDetail);
+  const viewData = new DataView(data.buffer);
+  /**
+   * 开锁方式操作
+   */
+  if (localRecordUnlock.includes(operClassify)) {
+    const unlockId = viewData.getInt16(0);
+    return {
+      category: operClassify,
+      unlockMethod: unlockMethodMap[operType],
+      unlockId,
+      isRemoveAll: unlockId === 0xffff,
+      userId,
+      userType,
+      toUserId,
+      toUserType
+    };
+  }
+  /**
+   * 添加用户操作
+   */
+  if (localRecordUserOperate.includes(operClassify)) {
+    return {
+      category: operClassify,
+      userId,
+      userType,
+      toUserId,
+      toUserType
+    };
+  }
+  /**
+   * 本地设置操作
+   */
+  if (operClassify === LocalOperateCategory.SETTING) {
+    return {
+      category: LocalOperateCategory.SETTING,
+      userId,
+      userType,
+      toUserId,
+      toUserType,
+      type: operType,
+      data: data.length <= 4 ? bytesToUint(data) : data,
+      originData: data
+    };
+  }
+  return {
+    category: operClassify,
+    type: operType,
+    data: data,
+    userId,
+    userType,
+    toUserId,
+    toUserType
+  };
+};

package/lib/utils/publishDps.d.ts

@@ -0,0 +1,11 @@
+import { DpValue } from "../interface";
+/**
+ * 执行下发 dp
+ * @param dpData
+ * @returns
+ */
+export declare const publishDpsOnly: (dpData: Record<string, string | number | boolean>) => Promise<void>;
+export declare const publishDps: (dpData: Record<string, DpValue>, option?: {
+    timeout?: number;
+    checkReport?: (dps: Record<string, any>) => boolean | Record<string, any>;
+}) => Promise<Record<string, DpValue>>;

package/lib/utils/publishDps.js

@@ -0,0 +1,91 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.reduce.js";
+import config from "../config";
+import { isOnlineByType } from ".";
+import { publishDeviceDps } from "./device";
+import emitter from "./event";
+import { DPCHANGE } from "./constant";
+import { getError } from "./errors";
+
+/**
+ * 执行下发 dp
+ * @param dpData
+ * @returns
+ */
+export const publishDpsOnly = async dpData => {
+  console.log("_publishDps", dpData);
+  const {
+    devInfo,
+    idsByCode
+  } = config;
+  const option = {};
+  if (config.onlineType === 0) {
+    // 设备离线
+    throw getError(1001);
+  }
+  if (isOnlineByType(config.onlineType, 2)) {
+    // 由于设备只能支持wifi 或蓝牙在线，wifi 在线又可能为假在线，因此当蓝牙在线时，优先走蓝牙通道
+    option.pipelines = [3];
+  }
+  const dps = Object.keys(dpData).reduce((acc, key) => {
+    const id = idsByCode[key];
+    if (id) {
+      acc[id] = dpData[key];
+    }
+    return acc;
+  }, {});
+  if (Object.keys(dps).length > 0) {
+    await publishDeviceDps(_objectSpread({
+      deviceId: devInfo.devId,
+      dps
+    }, option));
+  }
+};
+
+// 发送 dp 并等待上报
+export const publishDps = async (dpData, option) => {
+  await publishDpsOnly(dpData);
+  console.log("publishDps success");
+  // 默认 15s 超时
+  const {
+    timeout = 15000,
+    checkReport
+  } = option || {};
+  return new Promise((resolve, reject) => {
+    const codes = Object.keys(dpData);
+    const result = {};
+    const handleChangeDp = dpCodes => {
+      // 是否自定义检查上报数据
+      if (checkReport) {
+        const pass = checkReport(dpCodes);
+        if (pass) {
+          emitter.off(DPCHANGE, handleChangeDp);
+          clearTimeout(timer);
+          resolve(typeof pass !== "boolean" ? pass : dpCodes);
+        }
+      } else {
+        Object.keys(dpCodes).forEach(code => {
+          const eixst = codes.indexOf(code);
+          if (eixst > -1) {
+            codes.splice(eixst, 1)[0];
+            result[code] = dpCodes[code];
+          }
+        });
+        // 所有 dp 都上报了
+        if (codes.length === 0) {
+          emitter.off(DPCHANGE, handleChangeDp);
+          clearTimeout(timer);
+          resolve(result);
+        }
+      }
+    };
+    // 超时处理
+    const timer = setTimeout(() => {
+      emitter.off(DPCHANGE, handleChangeDp);
+      reject(getError(1002));
+    }, timeout);
+    emitter.on(DPCHANGE, handleChangeDp);
+  });
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@ray-js/lock-sdk",
+  "version": "1.0.0-beta-1",
+  "files": [
+    "lib"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "ray build --type=component",
+    "compile": "ray build --type=component",
+    "lint": "eslint . --max-warnings 0",
+    "generate:component": "turbo gen react-component",
+    "check-types": "tsc --noEmit"
+  },
+  "maintainers": [
+    "tuya_npm",
+    {
+      "name": "tuyafe"
+    }
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@turbo/gen": "^2.4.0",
+    "@types/node": "^22.13.0",
+    "@types/react": "19.0.8",
+    "eslint": "^9.21.0",
+    "typescript": "5.7.3"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "dependencies": {
+    "@ray-js/tuya-dp-transform": "^0.0.6",
+    "js-base64": "^3.7.7"
+  }
+}