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

package/lib/utils/event.js

@@ -0,0 +1,144 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.some.js";
+function createEmitter() {
+  let listeners = {};
+  let cachedEvents = {};
+  function addEvent(type, cb, emitType) {
+    if (!listeners[type]) {
+      listeners[type] = [];
+    }
+    // 确认一个事件只注册一次
+    const index = listeners[type].findIndex(item => item.cb === cb);
+    if (index === -1) {
+      listeners[type].push({
+        type: emitType,
+        cb
+      });
+    } else {
+      // 执行类型是否变更
+      if (listeners[type][index].type !== emitType) {
+        listeners[type][index].type = emitType;
+      }
+    }
+  }
+
+  /**
+   * 注册事件监听
+   * @param type
+   * @param cb
+   */
+
+  /**
+   * 注册事件监听
+   * 事件只会执行一次
+   * @param type
+   * @param cb
+   */
+
+  /**
+   * 是否有事件监听
+   * @param type
+   * @returns
+   */
+  function hasListener(type) {
+    return !!listeners[type] && listeners[type].length > 0;
+  }
+
+  /**
+   * 缓存事件，当有监听器时直接执行
+   * 事件会被缓存，直到有监听器时才会执行
+   * @param type
+   */
+
+  /**
+   * 清除缓存事件
+   * @param type
+   */
+  function clearCache(type) {
+    cachedEvents[type] = [];
+  }
+
+  /**
+   * 移除事件监听
+   * @param type
+   * @param cb
+   * @returns
+   */
+  function off(type, cb) {
+    if (!listeners[type]) {
+      return;
+    }
+    listeners[type].some((item, i) => {
+      if (item.cb === cb) {
+        listeners[type].splice(i, 1);
+        return true;
+      }
+      return false;
+    });
+  }
+
+  /**
+   * 执行事件
+   * @param type
+   * @param data
+   */
+  function emit(type, data) {
+    if (listeners[type]) {
+      // 取得事件列表的副本进行操作，以保证所有事件被执行
+      const list = [...listeners[type]];
+      const count = list.length;
+      for (let i = 0; i < count; i++) {
+        const {
+          cb,
+          type: cbType
+        } = list[i];
+        if (cbType === "once") {
+          listeners[type].splice(i, 1);
+        }
+        try {
+          cb(data);
+        } catch (e) {
+          // 监听事件执行不影响同步任务
+          console.warn(e);
+        }
+      }
+    }
+  }
+
+  /**
+   * 清除事件监听
+   */
+
+  return {
+    on: function on(type, cb) {
+      addEvent(type, cb, "on");
+
+      // 是否有缓存事件数据
+      if (cachedEvents[type] && cachedEvents[type].length > 0) {
+        // 执行缓存事件
+        cachedEvents[type].forEach(data => {
+          emit(type, data);
+        });
+        // 清除缓存事件
+        clearCache(type);
+      }
+    },
+    off,
+    once: function once(type, cb) {
+      addEvent(type, cb, "once");
+    },
+    emit,
+    clear: () => {
+      listeners = {};
+    },
+    hasListener,
+    cache: function cache(type, data) {
+      cachedEvents[type] = cachedEvents[type] || [];
+      cachedEvents[type].push(data);
+    },
+    clearCache
+  };
+}
+export { createEmitter };
+export default createEmitter();

package/lib/utils/hex-to-base64.d.ts

@@ -0,0 +1 @@
+export default function hexToBase64(value: string): string;

package/lib/utils/hex-to-base64.js

@@ -0,0 +1,8 @@
+import { Base64 } from 'js-base64';
+import hexToBytes from './hex-to-bytes';
+export default function hexToBase64(value) {
+  if (!value) {
+    return '';
+  }
+  return Base64.fromUint8Array(hexToBytes(value));
+}

package/lib/utils/hex-to-bytes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 将 hex 字符串转为字节数据
+ * @param value
+ * @returns
+ */
+export default function hexToBytes(value: string): Uint8Array<ArrayBuffer>;

package/lib/utils/hex-to-bytes.js

@@ -0,0 +1,16 @@
+/**
+ * 将 hex 字符串转为字节数据
+ * @param value
+ * @returns
+ */
+export default function hexToBytes(value) {
+  if (value.length % 2 !== 0) {
+    throw new Error('hex length error');
+  }
+  const len = value.length / 2;
+  const data = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    data[i] = parseInt(value.slice(i * 2, i * 2 + 2), 16);
+  }
+  return data;
+}

package/lib/utils/index.d.ts

@@ -0,0 +1,169 @@
+import { UserType } from "../constant";
+import { EffectiveConfig, UnlockMethodConfig, Week } from "../interface";
+import { LoopTypes } from "./constant";
+/**
+ * 格式化为24时间格式
+ * @param time
+ * @returns
+ */
+export declare const get24Time: (time: number) => number[];
+export declare const getNowTime: () => number;
+/**
+ * 判断设备在线类型
+ * @param onlineType 设备的通道在线数据
+ * @param type 待检测的通道类型，0为wifi，1为局域网，2为蓝牙，3为Mesh,  4为 beacon
+ * @returns
+ */
+export declare const isOnlineByType: (onlineType: number, type: number) => boolean;
+export declare function isCapability(capability: number, id: number): boolean;
+/**
+ * 获取产品支持的通讯能力
+ * @param capability 产品能力值
+ * @returns
+ */
+export declare function getCapabilities(capability: number): ({
+    readonly id: 0;
+    readonly name: "wifi";
+    readonly short: "wf";
+} | {
+    readonly id: 1;
+    readonly name: "cable";
+    readonly short: "ca";
+} | {
+    readonly id: 2;
+    readonly name: "gprs";
+    readonly short: "gp";
+} | {
+    readonly id: 3;
+    readonly name: "nb-iot";
+    readonly short: "nb";
+} | {
+    readonly id: 10;
+    readonly name: "bluetooth";
+    readonly short: "ble";
+} | {
+    readonly id: 11;
+    readonly name: "blemesh";
+    readonly short: "bm";
+} | {
+    readonly id: 12;
+    readonly name: "zigbee";
+    readonly short: "zig";
+} | {
+    readonly id: 13;
+    readonly name: "infrared";
+    readonly short: "inf";
+} | {
+    readonly id: 14;
+    readonly name: "subpieces";
+    readonly short: "sub";
+} | {
+    readonly id: 15;
+    readonly name: "sigmesh";
+    readonly short: "sig";
+} | {
+    readonly id: 16;
+    readonly name: "mcu";
+    readonly short: "mcu";
+} | {
+    readonly id: 17;
+    readonly name: "ty_smesh";
+    readonly short: "TY_SMESH";
+} | {
+    readonly id: 18;
+    readonly name: "Zwave";
+    readonly short: "Zwave";
+} | {
+    readonly id: 19;
+    readonly name: "pl-mesh";
+    readonly short: "pl-mesh";
+} | {
+    readonly id: 20;
+    readonly name: "cat1";
+    readonly short: "cat1";
+} | {
+    readonly id: 21;
+    readonly name: "beacon";
+    readonly short: "beacon";
+} | {
+    readonly id: 22;
+    readonly name: "cat4";
+    readonly short: "cat4";
+} | {
+    readonly id: 23;
+    readonly name: "cat10";
+    readonly short: "cat10";
+} | {
+    readonly id: 24;
+    readonly name: "lte-catm";
+    readonly short: "catm";
+} | {
+    readonly id: 25;
+    readonly name: "thread";
+    readonly short: "thread";
+})[];
+export declare const formatWeek: (value: number[]) => number;
+export declare const parseWeek: (value: number) => Week;
+/**
+ * 获取一个永久生效的设置
+ * @returns
+ */
+export declare const getPermanentSetting: () => {
+    startTime: number;
+    endTime: number;
+    loop: LoopTypes;
+    loopConfig: number;
+    weeks: number[];
+    days: never[];
+    startHour: number;
+    startMinute: number;
+    endHour: number;
+    endMinute: number;
+};
+export declare const isAdmin: (userType: UserType) => boolean;
+export declare const validateEffectiveConfig: (effective?: EffectiveConfig) => void;
+/**
+ * 是否使用近场通道，一般为蓝牙
+ * @returns
+ */
+export declare const isUseNearChannel: () => boolean;
+export declare const parseOfflinePassword: (value: string) => string;
+/**
+ * 格式化时间戳为毫秒
+ * 注意此方法只支持 2010 年之后的时间戳
+ * @param timestamp 时间戳
+ */
+export declare const formatTimestampToMilliseconds: (timestamp: number) => number;
+/**
+ * 开锁方式配置数据
+ */
+export declare const unlockMethodConfigs: UnlockMethodConfig[];
+export declare const getUnlockMethodTypeByDpCode: (dpCode: string) => UnlockMethodConfig;
+export declare const getUnlockMethodTypeById: (id: number) => UnlockMethodConfig;
+export declare const getUnlockMethodTypeByType: (type: string) => UnlockMethodConfig;
+/**
+ * 针对异常函数，当函数在短时间内被多次调用时，只保留最先一次调用，并统一返回结果
+ * @param cb 回调函数
+ * @returns
+ */
+export declare const parallelMerge: <T extends (...args: any[]) => Promise<any>>(cb: T) => (...args: Parameters<T>) => ReturnType<T>;
+/**
+ * 针对异常函数，当函数在短时间内被多次调用时，只允许函数在短时间内执行一次
+ * @param cb 回调函数
+ * @returns
+ */
+export declare const parallelOnly: <T extends (...args: any[]) => Promise<any>>(cb: T) => (...args: Parameters<T>) => ReturnType<T>;
+declare const preFetchKeys: readonly ["getRotate", "getCurrentUser", "getDeviceProperties"];
+type PreFetchKey = (typeof preFetchKeys)[number];
+export declare const getDataWithPreFetch: <T>(key: PreFetchKey, apiCb: () => Promise<T>) => Promise<T>;
+export declare const equels: (source: any, target: any) => boolean;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const getHomeInfo: () => Promise<{
+    homeName: string;
+    homeId: string;
+    longitude: string;
+    latitude: string;
+    address: string;
+    admin: boolean;
+}>;
+export {};