@ray-js/lock-sdk 1.1.3 → 1.2.0-beta.2

package/lib/other.js

@@ -1,291 +0,0 @@
-import dpUtils from "@ray-js/tuya-dp-transform";
-import config, { hasCapability, hasDp } from "./config";
-import dpCodes from "./config/dp-code";
-import { ProductCommunicationType } from "./constant";
-import { getDeviceStatus, getDpValue } from "./state";
-import { connectBLEDevice, encrypt, getBLEOnlineState, navigateToMiniProgram, offBleChange, offOnlineChange, onBleChange, onOnlineChange, openPanel, } from "./utils/device";
-import { getError } from "./utils/errors";
-import { publishDps } from "./utils/publishDps";
-import ipc from "./utils/ipc";
-import { DPCHANGE } from "./utils/constant";
-import emitter from "./utils/event";
-import { getOfflineDpCache, publishOfflineDps } from "./offline-dps";
-import { validatePasswordComplexity } from "./api/lock";
-const { alarmLock, unlockFingerprint, unlockPassword, unlockCard, unlockKey, unlockPhoneRemote, unlockTemporary, unlockDynamic, unlockFace, unlockHand, unlockEye, unlockFingerVein, unlockInside, doorOpened, unlockApp, unlockOfflinePd, openInside, lockRecord, unlockDoubleKit, lockLocalRecord, wirelessAwake, } = dpCodes;
-const abilityMap = {
-    backHome: "supportBackHome",
-    alarm: "supportAlarm",
-};
-export const openScene = async (options) => {
-    const dpIds = [
-        unlockFingerprint,
-        unlockPassword,
-        unlockCard,
-        unlockKey,
-        unlockPhoneRemote,
-        unlockTemporary,
-        unlockDynamic,
-        unlockFace,
-        unlockHand,
-        unlockEye,
-        unlockFingerVein,
-        unlockInside,
-        doorOpened,
-        unlockApp,
-        unlockOfflinePd,
-        openInside,
-        lockRecord,
-        unlockDoubleKit,
-        lockLocalRecord,
-    ].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,
-        });
-    });
-};
-export const isSupportBleControl = () => {
-    const { devInfo, idsByCode } = config;
-    const hasThread = hasCapability(ProductCommunicationType.THREAD);
-    const hasWifi = hasCapability(ProductCommunicationType.WIFI);
-    const hasBle = hasCapability(ProductCommunicationType.BLUETOOTH);
-    if (!hasBle) {
-        return false;
-    }
-    if (hasWifi && hasBle) {
-        if (!hasDp(dpCodes.unlockBle)) {
-            return false;
-        }
-        if (devInfo.wifiEnableState === 1) {
-            return true;
-        }
-    }
-    if (hasThread && hasBle) {
-        if (!devInfo?.meta?.["threadWithBLE"]) {
-            return false;
-        }
-    }
-    const bleControlDp = idsByCode[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 hasBle;
-};
-const periodDpMap = [
-    { name: "startHour" },
-    { name: "startMinute" },
-    { name: "endHour" },
-    { name: "endMinute" },
-];
-export const getDpPeriodTime = (dpCode) => {
-    if (hasDp(dpCode)) {
-        const { supportOfflineDps } = config;
-        let dpValue = getDpValue(dpCode);
-        if (supportOfflineDps) {
-            const cache = getOfflineDpCache(dpCode);
-            if (cache && cache.pushStatus === false) {
-                dpValue = cache.value;
-            }
-        }
-        return parseDpPeriodTime(dpValue);
-    }
-    return {
-        start: 0,
-        end: 0,
-    };
-};
-export const updateDpPeriodTime = (dpCode, data, option) => {
-    const { supportOfflineDps } = config;
-    if (!hasDp(dpCode)) {
-        throw getError(1014);
-    }
-    const dpValue = formatDpPeriodTime(data.start, data.end);
-    if (supportOfflineDps) {
-        const deviceStatus = getDeviceStatus();
-        if (deviceStatus.type !== "online" && option?.offlineDp) {
-            return publishOfflineDps({
-                [dpCode]: dpValue,
-            });
-        }
-    }
-    return publishDps({
-        [dpCode]: dpValue,
-    });
-};
-export const parseDpPeriodTime = (dpValue) => {
-    if (!dpValue) {
-        return {
-            start: 0,
-            end: 0,
-        };
-    }
-    const data = dpUtils.parse(dpValue, periodDpMap);
-    return {
-        start: (data.startHour ?? 0) * 60 + (data.startMinute ?? 0),
-        end: (data.endHour ?? 0) * 60 + (data.endMinute ?? 0),
-    };
-};
-export const formatDpPeriodTime = (start, end) => {
-    const startHour = Math.floor(start / 60);
-    const startMinute = start % 60;
-    const endHour = Math.floor(end / 60);
-    const endMinute = end % 60;
-    return dpUtils.format({
-        startHour,
-        startMinute,
-        endHour,
-        endMinute,
-    }, periodDpMap);
-};
-const awakeDevice = async (timeout) => {
-    return new Promise((resolve, reject) => {
-        const handleChangeDp = (dpCodes) => {
-            if (dpCodes[wirelessAwake] === true) {
-                resolve(true);
-                emitter.off(DPCHANGE, handleChangeDp);
-                clearTimeout(timer);
-            }
-        };
-        emitter.on(DPCHANGE, handleChangeDp);
-        const timer = setTimeout(() => {
-            emitter.off(DPCHANGE, handleChangeDp);
-            reject(getError(1002));
-        }, timeout || 15000);
-        const run = async () => {
-            try {
-                ipc.wakeUpDoorBell(config.devInfo.devId);
-                ipc.wakeUpDoorBell(config.devInfo.devId);
-                ipc.wakeUpDoorBell(config.devInfo.devId);
-                const connected = await ipc.isConnected(config.devInfo.devId);
-                if (connected.isConnected) {
-                    return resolve(true);
-                }
-                const connecting = await ipc.isConnecting(config.devInfo.devId);
-                if (!connecting.isConnecting) {
-                    await ipc.connect(config.devInfo.devId);
-                }
-            }
-            catch (error) {
-                reject(error);
-            }
-        };
-        run();
-    });
-};
-const connectBle = async () => {
-    return new Promise((resolve, reject) => {
-        const handleConnect = () => {
-            const handleStatusChange = ({ deviceId, status }) => {
-                if (deviceId === config.devInfo.devId && status === "CONNECTED") {
-                    clearTimer();
-                    resolve(true);
-                }
-            };
-            const handleOnline = ({ deviceId, online }) => {
-                if (deviceId === config.devInfo.devId && online) {
-                    clearTimer();
-                    resolve(true);
-                }
-            };
-            onBleChange(handleStatusChange);
-            onOnlineChange(handleOnline);
-            const timer = setTimeout(() => {
-                offBleChange(handleStatusChange);
-                offOnlineChange(handleOnline);
-                reject(new Error("timeout"));
-            }, 15000);
-            const clearTimer = () => {
-                clearInterval(timer);
-                offBleChange(handleStatusChange);
-                offOnlineChange(handleOnline);
-            };
-            connectBLEDevice(config.devInfo.devId).catch((e) => {
-                clearTimer();
-                reject(e);
-            });
-        };
-        getBLEOnlineState(config.devInfo.devId)
-            .then((isBleOnline) => {
-            if (isBleOnline) {
-                resolve(true);
-            }
-            else {
-                handleConnect();
-            }
-        })
-            .catch((e) => {
-            handleConnect();
-        });
-    });
-};
-export const connectDevice = async () => {
-    const deviceStatus = getDeviceStatus();
-    const hasWirelessAwakeDp = !!config.dpSchema[wirelessAwake];
-    if (hasWirelessAwakeDp) {
-        if (config.devInfo.isCloudOnline && !getDpValue(wirelessAwake)) {
-            return await awakeDevice();
-        }
-    }
-    if (isSupportBleControl()) {
-        if (deviceStatus.type === "online" && deviceStatus.onlineTypes.includes("ble")) {
-            return true;
-        }
-        return await connectBle();
-    }
-    throw getError(1062);
-};
-export const gotoService = async (params) => {
-    let type = 0;
-    if (params?.tab === "AI") {
-        type = 3;
-    }
-    return new Promise((resolve, reject) => {
-        const url = `godzilla://tyawqoyej4wi3pqebb?deviceId=${config.devInfo.devId}&commodityType=${type}`;
-        navigateToMiniProgram({
-            position: "bottom",
-            shortLink: url,
-            success: resolve,
-            fail: reject,
-        });
-    });
-};
-export const validatePwdComplexity = async (password) => {
-    const encryptedPassword = await encrypt(config.devInfo.devId, password);
-    return validatePasswordComplexity({
-        devId: config.devInfo.devId,
-        password: encryptedPassword,
-    });
-};

package/lib/signal.d.ts

@@ -1,14 +0,0 @@
-export declare const getWiFiSignal: () => Promise<{
-    fetchedData: Record<string, {
-        fetchedData: any;
-        timeStamp: number;
-    }>;
-} | null>;
-export declare const getCurrentWiFiSignal: () => number | "unknown";
-type WiFiSignalChangeListener = (params: {
-    signal: number;
-    level: "good" | "normal" | "weak" | "bad";
-}) => void;
-export declare const onWiFiSignalChange: (cb: WiFiSignalChangeListener) => void;
-export declare const offWiFiSignalChange: (cb: WiFiSignalChangeListener) => void;
-export {};

package/lib/signal.js

@@ -1,31 +0,0 @@
-import config from "./config";
-import { sendMqttMessage } from "./utils/device";
-import { getError } from "./utils/errors";
-import emitter from "./utils/event";
-let currentWiFiSignal = "unknown";
-export const getWiFiSignal = () => {
-    if (config.devInfo.isCloudOnline) {
-        return sendMqttMessage({
-            deviceId: config.devInfo.devId,
-            protocol: 22,
-            message: {
-                reqType: "sigQry",
-            },
-        });
-    }
-    else {
-        throw getError(1001);
-    }
-};
-export const getCurrentWiFiSignal = () => {
-    return currentWiFiSignal;
-};
-export const onWiFiSignalChange = (cb) => {
-    emitter.on("onWiFiSignalChange", cb);
-};
-export const offWiFiSignalChange = (cb) => {
-    emitter.off("onWiFiSignalChange", cb);
-};
-onWiFiSignalChange(({ signal }) => {
-    currentWiFiSignal = signal;
-});

package/lib/sleep.d.ts

@@ -1,19 +0,0 @@
-export declare const isSleep: () => boolean;
-export declare const hasSleepAbility: () => boolean;
-export declare const isEnabledSleep: () => import("./interface").DpValue;
-export declare const enableSleep: () => Promise<void | Record<string, import("./interface").DpValue>>;
-export declare const disableSleep: () => Promise<void | Record<string, import("./interface").DpValue>>;
-export declare const getSleepPeriod: () => {
-    start: number;
-    end: number;
-};
-export declare const updateSleepPeriod: (params: {
-    start: number;
-    end: number;
-}) => Promise<void> | Promise<Record<string, import("./interface").DpValue>>;
-export declare const onSleepStatusChange: (callback: (args: {
-    sleep: boolean;
-}) => void) => void;
-export declare const offSleepStatusChange: (callback: (args: {
-    sleep: boolean;
-}) => void) => void;

package/lib/sleep.js

@@ -1,79 +0,0 @@
-import config, { hasDp } from "./config";
-import { getDeviceStatus, getDpValue } from "./state";
-import { getError } from "./utils/errors";
-import { publishDps } from "./utils/publishDps";
-import emitter from "./utils/event";
-import { SLEEP_EVENT } from "./event";
-import dpCodes from "./config/dp-code";
-import { getDpPeriodTime, updateDpPeriodTime } from "./other";
-import { getOfflineDpCache, publishOfflineDps } from "./offline-dps";
-export const isSleep = () => {
-    if (!hasDp(dpCodes.linkMode)) {
-        return false;
-    }
-    const linkMode = getDpValue(dpCodes.linkMode);
-    return linkMode === "sleep" || linkMode === "lock_sleep";
-};
-export const hasSleepAbility = () => {
-    return ((hasDp(dpCodes.dormantSwitch) || hasDp(dpCodes.onlineSwitch)) &&
-        hasDp(dpCodes.dormantTimeSet));
-};
-const setSleepStatus = async (status, option) => {
-    const { supportOfflineDps } = config;
-    if (hasSleepAbility()) {
-        const dpCode = hasDp(dpCodes.onlineSwitch)
-            ? dpCodes.onlineSwitch
-            : dpCodes.dormantSwitch;
-        if (supportOfflineDps) {
-            const deviceStatus = getDeviceStatus();
-            if (deviceStatus.type !== "online" && option?.offlineDp) {
-                return publishOfflineDps({
-                    [dpCode]: status,
-                });
-            }
-        }
-        return publishDps({
-            [dpCode]: status,
-        });
-    }
-    throw getError(1014);
-};
-const getSwitchStatus = () => {
-    const { supportOfflineDps } = config;
-    const hasOnlineSwitch = hasDp(dpCodes.onlineSwitch);
-    const hasDormantSwitch = hasDp(dpCodes.dormantSwitch);
-    if (!hasOnlineSwitch && !hasDormantSwitch) {
-        return false;
-    }
-    const dpCode = hasOnlineSwitch ? dpCodes.onlineSwitch : dpCodes.dormantSwitch;
-    if (supportOfflineDps) {
-        const cache = getOfflineDpCache(dpCode);
-        if (cache && cache.pushStatus === false) {
-            return cache.value;
-        }
-    }
-    return getDpValue(dpCode);
-};
-export const isEnabledSleep = () => {
-    return getSwitchStatus();
-};
-export const enableSleep = async () => {
-    return setSleepStatus(true);
-};
-export const disableSleep = async () => {
-    return setSleepStatus(false);
-};
-export const getSleepPeriod = () => {
-    return getDpPeriodTime(dpCodes.dormantTimeSet);
-};
-export const updateSleepPeriod = (params) => {
-    return updateDpPeriodTime(dpCodes.dormantTimeSet, params, {
-        offlineDp: true,
-    });
-};
-export const onSleepStatusChange = (callback) => {
-    emitter.on(SLEEP_EVENT, callback);
-};
-export const offSleepStatusChange = (callback) => {
-    emitter.off(SLEEP_EVENT, callback);
-};

package/lib/state.d.ts

@@ -1,16 +0,0 @@
-import { DpValue, CurrentUser, RemotePermission, DeviceStatus } from "./interface";
-export declare const clearState: () => void;
-export declare const getDpValue: (code: string) => DpValue;
-export declare const getDeviceStatus: () => DeviceStatus;
-export declare const getCurrentUser: (isForce?: boolean) => Promise<CurrentUser>;
-export declare const getCurrentUserSync: () => CurrentUser | null;
-export declare const getMediaRotate: () => {
-    imageAngle: number;
-    videoAngle: number;
-};
-export declare const permissions: RemotePermission[];
-export declare const initState: () => Promise<void>;
-export declare const addEvents: () => void;
-export declare const removeEvents: () => void;
-export declare const onDeviceStatusChange: (callback: (status: DeviceStatus) => void) => void;
-export declare const offDeviceStatusChange: (callback: (status: DeviceStatus) => void) => void;