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

package/lib/open/ble-dedicated-dp.d.ts

@@ -1,4 +0,0 @@
-export declare const isDedicatedBleHexSuccess: (raw: string) => boolean;
-export declare const resolveDedicatedBleCommandDp: () => string | null;
-export declare const executeDedicatedBleManualLock: (timeout: number) => Promise<void>;
-export declare const executeDedicatedBleRawAction: (isOpen: boolean, timeout: number) => Promise<void>;

package/lib/open/ble-dedicated-dp.js

@@ -1,148 +0,0 @@
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { getDoorKey } from "../api/lock";
-import config, { hasDp } from "../config";
-import dpCodes from "../config/dp-code";
-import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
-import syncRemoteSerectKey from "../sync/remote-serect-key";
-import { stringToBytes } from "../utils/byte";
-import { decrypt } from "../utils/device";
-import { getError } from "../utils/errors";
-import { publishDps } from "../utils/publishDps";
-import { getOpenDoorMemberId } from "./ble-remote-no-dp-key";
-import { mapRemoteOpenReportStatus } from "./report-status";
-const normalizeHex = (raw) => raw.replace(/\s/g, "").toLowerCase();
-export const isDedicatedBleHexSuccess = (raw) => {
-    const n = normalizeHex(raw);
-    if (n.length < 2) {
-        return false;
-    }
-    return n.startsWith("00") || n.endsWith("00");
-};
-const parseDedicatedBleHexStatus = (raw) => {
-    const n = normalizeHex(raw);
-    if (n.length < 2) {
-        return false;
-    }
-    if (isDedicatedBleHexSuccess(raw)) {
-        return { status: 0 };
-    }
-    if (n.includes("06")) {
-        return { status: 0x06 };
-    }
-    return { status: 0x01 };
-};
-const tryParseStandardUnlockReport = (raw, memberId) => {
-    try {
-        const result = dpUtils.parse(raw, reportOpenMap);
-        if (result.memberId !== memberId) {
-            return false;
-        }
-        if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
-            return false;
-        }
-        return result;
-    }
-    catch {
-        return false;
-    }
-};
-export const resolveDedicatedBleCommandDp = () => {
-    if (hasDp(dpCodes.bleUnlockCheck)) {
-        return dpCodes.bleUnlockCheck;
-    }
-    if (hasDp(dpCodes.bluetoothUnlock)) {
-        return dpCodes.bluetoothUnlock;
-    }
-    if (hasDp(dpCodes.unlockBle)) {
-        return dpCodes.unlockBle;
-    }
-    return null;
-};
-const createDedicatedBleCheckReport = (commandDp, memberId) => {
-    return (dpData) => {
-        if (hasDp(dpCodes.lockMotorState)) {
-            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
-                return { status: 0 };
-            }
-        }
-        if (typeof dpData[commandDp] !== "undefined") {
-            const raw = dpData[commandDp];
-            const standard = tryParseStandardUnlockReport(raw, memberId);
-            if (standard) {
-                return standard;
-            }
-            const hexStatus = parseDedicatedBleHexStatus(raw);
-            if (hexStatus !== false) {
-                return hexStatus;
-            }
-        }
-        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
-            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
-            if (result.memberId === memberId) {
-                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
-                    return false;
-                }
-                return result;
-            }
-        }
-        return false;
-    };
-};
-export const executeDedicatedBleManualLock = async (timeout) => {
-    if (!hasDp(dpCodes.manualLock)) {
-        throw getError(1014);
-    }
-    await publishDps({
-        [dpCodes.manualLock]: true,
-    }, {
-        timeout,
-        checkReport: (dpData) => {
-            if (hasDp(dpCodes.lockMotorState)) {
-                if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
-                    return { status: 0 };
-                }
-            }
-            if (typeof dpData[dpCodes.manualLock] !== "undefined") {
-                return { status: 0 };
-            }
-            return false;
-        },
-    });
-};
-export const executeDedicatedBleRawAction = async (isOpen, timeout) => {
-    if (!isOpen && hasDp(dpCodes.manualLock)) {
-        await executeDedicatedBleManualLock(timeout);
-        return;
-    }
-    const commandDp = resolveDedicatedBleCommandDp();
-    if (!commandDp) {
-        throw getError(1014);
-    }
-    await syncRemoteSerectKey();
-    let pw = "";
-    try {
-        const { password } = await getDoorKey(config.devInfo.devId);
-        pw = await decrypt(config.devInfo.devId, password);
-    }
-    catch {
-        await syncRemoteSerectKey(true);
-        const { password } = await getDoorKey(config.devInfo.devId);
-        pw = await decrypt(config.devInfo.devId, password);
-    }
-    const memberId = await getOpenDoorMemberId();
-    const payload = dpUtils.format({
-        status: Number(isOpen),
-        memberId,
-        key: stringToBytes(pw),
-        type: 3,
-    }, openMap);
-    const response = (await publishDps({
-        [commandDp]: payload,
-    }, {
-        timeout,
-        checkReport: createDedicatedBleCheckReport(commandDp, memberId),
-    }));
-    if (response.status !== 0) {
-        throw mapRemoteOpenReportStatus(response.status);
-    }
-};

package/lib/open/ble-remote-no-dp-key.d.ts

@@ -1,4 +0,0 @@
-import { DpValue } from "../interface";
-export declare const createRemoteNoDpKeyBleCheckReport: (memberId: number) => (dpData: Record<string, DpValue>) => any;
-export declare const executeBleRemoteNoDpKeyAction: (isOpen: boolean, timeout: number, memberId: number) => Promise<void>;
-export declare const getOpenDoorMemberId: () => Promise<number>;

package/lib/open/ble-remote-no-dp-key.js

@@ -1,69 +0,0 @@
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { getDoorKey } from "../api/lock";
-import config, { hasDp } from "../config";
-import dpCodes from "../config/dp-code";
-import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
-import { getCurrentUser } from "../state";
-import syncRemoteSerectKey from "../sync/remote-serect-key";
-import { stringToBytes } from "../utils/byte";
-import { decrypt } from "../utils/device";
-import { publishDps } from "../utils/publishDps";
-import { mapRemoteOpenReportStatus } from "./report-status";
-export const createRemoteNoDpKeyBleCheckReport = (memberId) => {
-    return (dpData) => {
-        if (hasDp(dpCodes.lockMotorState)) {
-            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
-                return {
-                    status: 0,
-                };
-            }
-        }
-        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
-            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
-            if (result.memberId === memberId) {
-                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
-                    return false;
-                }
-                return result;
-            }
-            else {
-                console.warn("An incorrect member id was returned");
-            }
-        }
-        return false;
-    };
-};
-export const executeBleRemoteNoDpKeyAction = async (isOpen, timeout, memberId) => {
-    await syncRemoteSerectKey();
-    let pw = "";
-    try {
-        const { password } = await getDoorKey(config.devInfo.devId);
-        pw = await decrypt(config.devInfo.devId, password);
-    }
-    catch {
-        await syncRemoteSerectKey(true);
-        const { password } = await getDoorKey(config.devInfo.devId);
-        pw = await decrypt(config.devInfo.devId, password);
-    }
-    const response = (await publishDps({
-        [dpCodes.remoteNoDpKey]: dpUtils.format({
-            status: Number(isOpen),
-            memberId,
-            key: stringToBytes(pw),
-            type: 3,
-        }, openMap),
-    }, {
-        timeout,
-        checkReport: createRemoteNoDpKeyBleCheckReport(memberId),
-    }));
-    if (response.status !== 0) {
-        throw mapRemoteOpenReportStatus(response.status);
-    }
-};
-export const getOpenDoorMemberId = async () => {
-    const currentUser = await getCurrentUser();
-    if (currentUser.lockUserId !== 0) {
-        return Number(currentUser.lockUserId);
-    }
-    return Number(currentUser.userId);
-};

package/lib/open/report-status.d.ts

@@ -1 +0,0 @@
-export declare const mapRemoteOpenReportStatus: (status: number) => import("..").ErrorData;

package/lib/open/report-status.js

@@ -1,23 +0,0 @@
-import { getError } from "../utils/errors";
-export const mapRemoteOpenReportStatus = (status) => {
-    let error = getError(1004);
-    switch (status) {
-        case 0x02:
-            error = getError(1005);
-            break;
-        case 0x03:
-            error = getError(1006);
-            break;
-        case 0x04:
-            error = getError(1007);
-            break;
-        case 0x05:
-            error = getError(1008);
-            break;
-        case 0x06:
-            error = getError(1070);
-            break;
-        default:
-    }
-    return error;
-};

package/lib/open.d.ts

@@ -1,22 +0,0 @@
-import { RemotePermission } from "./interface";
-export declare const checkRemoteEnabled: () => Promise<void>;
-export declare const openDoor: (option?: {
-    timeout?: number;
-} | undefined) => Promise<void>;
-export declare const closeDoor: (option?: {
-    timeout?: number;
-} | undefined) => Promise<void>;
-export declare const remoteEnabled: (state: boolean) => Promise<void>;
-export declare const getRemoteEnabled: () => boolean;
-export declare const getRemotePermissionList: () => RemotePermission[];
-export declare const getRemotePermission: () => RemotePermission;
-export declare const updateRemotePermission: (permission: RemotePermission) => Promise<void>;
-export declare const getVoiceUnlockPwdEnabled: () => Promise<boolean>;
-export declare const voiceUnlockPwdDisabled: () => Promise<boolean>;
-export declare const updateVoiceUnlockPwd: (password: string) => Promise<boolean>;
-export declare const agreeOpenDoor: (option?: {
-    timeout?: number;
-} | undefined) => Promise<unknown>;
-export declare const rejectOpenDoor: (option?: {
-    timeout?: number;
-} | undefined) => Promise<unknown>;

package/lib/open.js

@@ -1,262 +0,0 @@
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { getDoorKey, openDoorByCloud, isConfirmOpenDoorByWifiPro, } from "./api/lock";
-import config, { hasCapability, hasDp } from "./config";
-import { isUseNearChannel, parallelMerge, parallelOnly } from "./utils";
-import { decrypt, encrypt } from "./utils/device";
-import { publishDps } from "./utils/publishDps";
-import { open as openMap, reportOpen as reportOpenMap, } from "./config/dp-map/open";
-import { stringToBytes } from "./utils/byte";
-import emitter from "./utils/event";
-import { getError } from "./utils/errors";
-import { DPCHANGE } from "./utils/constant";
-import dpCodes from "./config/dp-code";
-import { getCurrentUser, getDeviceStatus, permissions } from "./state";
-import { setDeviceProperties } from "./api/setting";
-import syncRemoteSerectKey from "./sync/remote-serect-key";
-import { ProductCommunicationType, UserType } from "./constant";
-import { getVoicePwdEnabled, setVoicePwd } from "./api";
-const getReportError = (status) => {
-    let error = getError(1004);
-    switch (status) {
-        case 0x02:
-            error = getError(1005);
-            break;
-        case 0x03:
-            error = getError(1006);
-            break;
-        case 0x04:
-            error = getError(1007);
-            break;
-        case 0x05:
-            error = getError(1008);
-            break;
-        default:
-    }
-    return error;
-};
-export const checkRemoteEnabled = parallelMerge(async () => {
-    const { dpSchema, remoteOpenEnabled, remoteOpenPermission } = config;
-    const { userType } = await getCurrentUser();
-    const deviceStatus = getDeviceStatus();
-    const hasThread = hasCapability(ProductCommunicationType.THREAD);
-    if (deviceStatus.type !== "online") {
-        throw getError(1001);
-    }
-    const isLocalOnline = deviceStatus.onlineTypes.length === 1 &&
-        deviceStatus.onlineTypes.includes("local");
-    const isThreadLocalOnline = hasThread && isLocalOnline;
-    if (isThreadLocalOnline || deviceStatus.onlineTypes.includes("ble")) {
-        return;
-    }
-    if (deviceStatus.isWifiMatter && isLocalOnline) {
-        return;
-    }
-    if (isLocalOnline) {
-        throw getError(1064);
-    }
-    if (dpSchema[dpCodes.remoteNoDpKey] === undefined) {
-        throw getError(1045);
-    }
-    if (!remoteOpenEnabled) {
-        throw getError(1046);
-    }
-    if (remoteOpenPermission === "noOne" ||
-        (remoteOpenPermission === "adminsOnly" &&
-            +userType !== UserType.ADMIN &&
-            +userType !== UserType.OWNER)) {
-        throw getError(1047);
-    }
-});
-const _doAction = async (isOpen, timeout) => {
-    const { devInfo, communication } = config;
-    await checkRemoteEnabled();
-    const deviceStatus = getDeviceStatus();
-    const hasThread = hasCapability(ProductCommunicationType.THREAD);
-    const isNear = isUseNearChannel();
-    const currentUser = await getCurrentUser();
-    const memberId = currentUser.lockUserId !== 0 ? currentUser.lockUserId : currentUser.userId;
-    const checkReport = (dpData) => {
-        if (hasDp(dpCodes.lockMotorState)) {
-            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
-                return {
-                    status: 0,
-                };
-            }
-        }
-        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
-            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
-            if (result.memberId === memberId) {
-                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
-                    return false;
-                }
-                return result;
-            }
-            else {
-                console.warn("An incorrect member id was returned");
-            }
-        }
-        return false;
-    };
-    console.log("-------", deviceStatus.isWifiMatter, deviceStatus.onlineTypes);
-    if ((hasThread || deviceStatus.isWifiMatter) &&
-        deviceStatus.onlineTypes.includes("local") &&
-        deviceStatus.onlineTypes.length === 1) {
-        await publishDps({ [dpCodes.matterLanUnlock]: isOpen }, {
-            checkReport: (dps) => {
-                if (hasDp(dpCodes.lockMotorState)) {
-                    if (typeof dps[dpCodes.lockMotorState] !== "undefined") {
-                        return true;
-                    }
-                }
-                return typeof dps[dpCodes.matterLanUnlock] !== "undefined";
-            },
-        });
-        return;
-    }
-    if (isNear) {
-        if (hasCapability(ProductCommunicationType.WIFI) ||
-            hasCapability(ProductCommunicationType.THREAD)) {
-            await syncRemoteSerectKey();
-            let pw = "";
-            try {
-                const { password } = await getDoorKey(devInfo.devId);
-                pw = await decrypt(devInfo.devId, password);
-            }
-            catch (e) {
-                await syncRemoteSerectKey(true);
-                const { password } = await getDoorKey(devInfo.devId);
-                pw = await decrypt(devInfo.devId, password);
-            }
-            const response = await publishDps({
-                [dpCodes.remoteNoDpKey]: dpUtils.format({
-                    status: Number(isOpen),
-                    memberId,
-                    key: stringToBytes(pw),
-                    type: 3,
-                }, openMap),
-            }, {
-                timeout,
-                checkReport,
-            });
-            if (response.status !== 0) {
-                throw getReportError(response.status);
-            }
-            return;
-        }
-        if (communication.length === 1 &&
-            hasCapability(ProductCommunicationType.BLUETOOTH)) {
-            throw new Error("Bluetooth lock opening is not supported yet");
-        }
-    }
-    return new Promise((resolve, reject) => {
-        const handleReport = (dpCodes) => {
-            const result = checkReport(dpCodes);
-            if (result) {
-                emitter.off(DPCHANGE, handleReport);
-                clearTimeout(timeoutTask);
-                if (result.status !== 0) {
-                    reject(getReportError(result.status));
-                }
-                else {
-                    resolve();
-                }
-            }
-        };
-        const timeoutTask = setTimeout(() => {
-            emitter.off(DPCHANGE, handleReport);
-            reject(getError(1002));
-        }, timeout);
-        emitter.on(DPCHANGE, handleReport);
-        openDoorByCloud(devInfo.devId, isOpen).catch((e) => {
-            clearTimeout(timeoutTask);
-            emitter.off(DPCHANGE, handleReport);
-            reject(getError(1003));
-        });
-    });
-};
-export const openDoor = parallelOnly((option) => {
-    return _doAction(true, option?.timeout || 15000);
-});
-export const closeDoor = parallelOnly((option) => {
-    return _doAction(false, option?.timeout || 15000);
-});
-export const remoteEnabled = parallelMerge(async (state) => {
-    await setDeviceProperties(config.devInfo.devId, {
-        UNLOCK_PHONE_REMOTE: state,
-    });
-    config.remoteOpenEnabled = state;
-    if (state) {
-        syncRemoteSerectKey();
-    }
-});
-export const getRemoteEnabled = () => {
-    return config.remoteOpenEnabled;
-};
-export const getRemotePermissionList = () => {
-    return permissions;
-};
-export const getRemotePermission = () => {
-    return config.remoteOpenPermission;
-};
-export const updateRemotePermission = async (permission) => {
-    const index = permissions.indexOf(permission);
-    await setDeviceProperties(config.devInfo.devId, {
-        REMOTE_UNLOCK_AUTH: index > 0 ? index : 0,
-    });
-    config.remoteOpenPermission = permission;
-};
-const handleOpenDoor = (confirm, timeout) => {
-    const { devInfo } = config;
-    return new Promise((resolve, reject) => {
-        const handleReport = (dpData) => {
-            if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
-                timeoutTask && clearTimeout(timeoutTask);
-                const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
-                if (result.status !== 0x00) {
-                    reject(getReportError(result.status));
-                }
-                else {
-                    resolve(true);
-                }
-            }
-        };
-        const timeoutTask = setTimeout(() => {
-            emitter.off(DPCHANGE, handleReport);
-            reject(getError(1002));
-        }, timeout);
-        emitter.on(DPCHANGE, handleReport);
-        isConfirmOpenDoorByWifiPro(devInfo.devId, confirm).catch((e) => {
-            timeoutTask && clearTimeout(timeoutTask);
-            emitter.off(DPCHANGE, handleReport);
-            reject(getError(1003));
-        });
-    });
-};
-export const getVoiceUnlockPwdEnabled = async () => {
-    const res = await getVoicePwdEnabled(config.devInfo.devId);
-    return res === true || res === 1;
-};
-export const voiceUnlockPwdDisabled = async () => {
-    return setVoicePwd({
-        devId: config.devInfo.devId,
-        open: false,
-        pwd: "",
-    });
-};
-export const updateVoiceUnlockPwd = async (password) => {
-    if (!/^\d{4,6}$/.test(password)) {
-        throw getError(1063);
-    }
-    const encryptedPassword = await encrypt(config.devInfo.devId, password);
-    return setVoicePwd({
-        devId: config.devInfo.devId,
-        open: true,
-        pwd: encryptedPassword,
-    });
-};
-export const agreeOpenDoor = parallelOnly((option) => {
-    return handleOpenDoor(true, option?.timeout || 15000);
-});
-export const rejectOpenDoor = parallelOnly((option) => {
-    return handleOpenDoor(false, option?.timeout || 15000);
-});

package/lib/other.d.ts

@@ -1,31 +0,0 @@
-import { DpValue } from "./interface";
-type ExecutorRange = "unlock" | "lock";
-type Ability = "backHome" | "alarm" | "geographyArrive" | "geographyLeave" | "bleGeofence" | "siriUnlock" | "siriLock";
-interface OpenSceneOptions {
-    themeColor?: string;
-    executorRange?: Array<ExecutorRange>;
-    abilities?: Array<Ability>;
-}
-export declare const openScene: (options?: OpenSceneOptions) => Promise<unknown>;
-export declare const isSupportBleControl: () => boolean;
-export declare const getDpPeriodTime: (dpCode: string) => {
-    start: number;
-    end: number;
-};
-export declare const updateDpPeriodTime: (dpCode: string, data: {
-    start: number;
-    end: number;
-}, option?: {
-    offlineDp?: boolean;
-}) => Promise<void> | Promise<Record<string, DpValue>>;
-export declare const parseDpPeriodTime: (dpValue: string) => {
-    start: number;
-    end: number;
-};
-export declare const formatDpPeriodTime: (start: number, end: number) => string;
-export declare const connectDevice: () => Promise<unknown>;
-export declare const gotoService: (params?: {
-    tab?: "cloudStorage" | "AI";
-}) => Promise<unknown>;
-export declare const validatePwdComplexity: (password: string) => Promise<boolean>;
-export {};