@ray-js/lock-sdk 1.1.0 → 1.1.1-beta.2

package/lib/api/temp.js

@@ -38,7 +38,7 @@ export const getTempPassword = (params) => {
 export const deleteTempPassword = (params) => {
     return requestApi({
         api: `${THING}.m.device.lock.temppwd.remove`,
-        version: "2.0",
+        version: "5.0",
         data: params,
     });
 };

package/lib/config/dp-code/index.d.ts

@@ -1,4 +1,5 @@
 declare const dpCodes: {
+    lockMotorState: string;
     remoteNoDpKey: string;
     remoteNoPdSetkey: string;
     synchMethodW: string;

package/lib/config/dp-code/index.js

@@ -1,4 +1,5 @@
 const dpCodes = {
+    lockMotorState: 'lock_motor_state',
     remoteNoDpKey: "remote_no_dp_key",
     remoteNoPdSetkey: "remote_no_pd_setkey",
     synchMethodW: "synch_method_w",

package/lib/config/dp-map/unlock-method-big.d.ts

@@ -382,17 +382,16 @@ declare const reportAddTempPwd: ({
     name: string;
     bytes?: undefined;
 })[];
-declare const removeTempPwd: {
-    name: string;
-    bytes: number;
-}[];
-declare const reportRemoveTempPwd: ({
-    name: string;
-    bytes: number;
-} | {
-    name: string;
-    bytes?: undefined;
-})[];
+declare const removeTempPwd: readonly [{
+    readonly name: "unlockId";
+    readonly bytes: 2;
+}];
+declare const reportRemoveTempPwd: readonly [{
+    readonly name: "unlockId";
+    readonly bytes: 2;
+}, {
+    readonly name: "status";
+}];
 declare const updateTempPwd: ({
     readonly name: "validConfig";
     readonly type: "child";

package/lib/index.js

@@ -61,8 +61,8 @@ export const init = async (options) => {
     config.idsByCode = idsByCode;
     config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
     config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
-    await initState();
     addEvents();
+    await initState();
 };
 export const destroy = () => {
     clearState();

package/lib/interface.d.ts

@@ -185,6 +185,7 @@ export interface DeviceStatus {
     type: "offline" | "online" | "sleep";
     connectEnable: boolean;
     onlineType: "local" | "cloud" | "ble" | "none" | "unknown";
+    onlineTypes: Array<"local" | "cloud" | "ble" | "localMatter" | "unknown">;
     sleepPeriod?: {
         start: number;
         end: number;

package/lib/open.js

@@ -1,6 +1,6 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { getDoorKey, openDoorByCloud, isConfirmOpenDoorByWifiPro, } from "./api/lock";
-import config, { hasCapability } from "./config";
+import config, { hasCapability, hasDp } from "./config";
 import { isUseNearChannel, parallelMerge, parallelOnly } from "./utils";
 import { decrypt, encrypt } from "./utils/device";
 import { publishDps } from "./utils/publishDps";
@@ -73,9 +73,19 @@ const _doAction = async (isOpen, timeout) => {
     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 {
@@ -229,7 +239,7 @@ export const updateVoiceUnlockPwd = async (password) => {
     const encryptedPassword = await encrypt(config.devInfo.devId, password);
     return setVoicePwd({
         devId: config.devInfo.devId,
-        open: false,
+        open: true,
         pwd: encryptedPassword,
     });
 };

package/lib/other.js

@@ -71,26 +71,26 @@ export const openScene = async (options) => {
     });
 };
 export const isSupportBleControl = () => {
-    const { devInfo, idsByCode, communication } = config;
-    if (!idsByCode[dpCodes.unlockBle]) {
-        return false;
-    }
+    const { devInfo, idsByCode } = config;
     const hasThread = hasCapability(ProductCommunicationType.THREAD);
     const hasWifi = hasCapability(ProductCommunicationType.WIFI);
     const hasBle = hasCapability(ProductCommunicationType.BLUETOOTH);
     if (!hasBle) {
         return false;
     }
-    if (hasThread) {
-        if (!devInfo?.meta?.["threadWithBLE"]) {
+    if (hasWifi && hasBle) {
+        if (!hasDp(dpCodes.unlockBle)) {
             return false;
         }
-    }
-    if (hasWifi && hasBle) {
         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];
@@ -101,7 +101,7 @@ export const isSupportBleControl = () => {
         }
         return getDpValue(dpCodes.bleControl);
     }
-    return true;
+    return hasBle;
 };
 const periodDpMap = [
     { name: "startHour" },

package/lib/state.js

@@ -1,4 +1,4 @@
-import config, { hasCapability } from "./config";
+import config, { hasCapability, hasDp } from "./config";
 import { onDpDataChange, onDeviceInfoUpdated, offDeviceInfoUpdated, offDpDataChange, registerDevice, getDeviceOnlineType, onOnlineChange, offOnlineChange, onBleChange, offBleChange, registerBleStatus, getDeviceInfo, onMqttMessage, registerMQTTDeviceListener, registerMQTTProtocolListener, offMqttMessage, onAppShow, onAppHide, } from "./utils/device";
 import { getDeviceProperties } from "./api/setting";
 import { parseCapabilities } from "./parse";
@@ -43,6 +43,7 @@ export const getDeviceStatus = () => {
         type: isOnline ? "online" : "offline",
         connectEnable: false,
         onlineType: "unknown",
+        onlineTypes: [],
         isWifiActive: wifiEnableState !== 1,
     };
     const isBleOnline = !isCloudOnline && isOnlineByType(onlineType, 2);
@@ -50,75 +51,62 @@ export const getDeviceStatus = () => {
     const supportWifi = hasCapability(ProductCommunicationType.WIFI);
     const supportBle = hasCapability(ProductCommunicationType.BLUETOOTH);
     const supportThread = hasCapability(ProductCommunicationType.THREAD);
-    const hasWirelessAwakeDp = !!dpSchema[dpCodes.wirelessAwake];
+    const hasWirelessAwakeDp = hasDp(dpCodes.wirelessAwake);
     const wirelessAwake = getDpValue(dpCodes.wirelessAwake);
-    const isDeviceOnline = hasWirelessAwakeDp
-        ? wirelessAwake && isCloudOnline
-        : isCloudOnline;
     status.connectEnable = isSupportBleControl() && !isOnline;
     if (supportWifi) {
         if (!status.connectEnable) {
-            status.connectEnable =
-                hasWirelessAwakeDp && wirelessAwake === false && !isBleOnline;
-        }
-    }
-    switch (communication.length) {
-        case 1: {
-            if (supportWifi) {
-                if (isDeviceOnline) {
-                    status.type = "online";
-                    status.onlineType = "cloud";
-                }
-                if (isSleep()) {
-                    status.type = "sleep";
-                }
+            if (isCloudOnline) {
+                status.connectEnable =
+                    hasWirelessAwakeDp && wirelessAwake === false && !isBleOnline;
             }
-            else if (supportBle) {
-                status.connectEnable = true;
-                if (isOnline) {
-                    status.type = "online";
-                    status.onlineType = "ble";
-                }
-            }
-            break;
         }
-        case 2: {
-            if (supportWifi && supportBle) {
-                if (!isDeviceOnline) {
-                    if (isBleOnline) {
-                        status.type = "online";
-                        status.onlineType = "ble";
-                        break;
-                    }
-                }
-                else {
-                    status.type = "online";
-                    status.onlineType = "cloud";
-                }
-                if (isSleep()) {
-                    status.type = "sleep";
-                }
-                break;
-            }
-            if (supportThread && supportBle) {
-                const isShareThread = isShareThead();
-                if (isLocalOnline || (isShareThread && isOnline)) {
-                    status.type = "online";
-                    status.onlineType = "local";
-                }
-                else if (isCloudOnline) {
-                    status.type = "online";
-                    status.onlineType = "cloud";
-                }
-                else if (isBleOnline) {
-                    status.type = "online";
-                    status.onlineType = "ble";
+    }
+    if (isOnline) {
+        if (isCloudOnline) {
+            if (hasWirelessAwakeDp) {
+                if (wirelessAwake) {
+                    status.onlineTypes.push("cloud");
                 }
                 else {
                     status.type = "offline";
                 }
             }
-            break;
+            else {
+                status.onlineTypes.push("cloud");
+            }
+        }
+        else if (isLocalOnline) {
+            status.onlineTypes.push("local");
+        }
+        if (isBleOnline) {
+            status.onlineTypes.push("ble");
+        }
+    }
+    if (status.onlineTypes.length === 0 && isOnline) {
+        status.onlineTypes.push("unknown");
+    }
+    if (supportThread && supportBle) {
+        const isShareThread = isShareThead();
+        if (isShareThread && isOnline) {
+            status.onlineTypes = ["local"];
+        }
+    }
+    if (status.onlineTypes.includes("ble")) {
+        status.onlineType = "ble";
+    }
+    else if (status.onlineTypes.includes("cloud")) {
+        status.onlineType = "cloud";
+    }
+    else if (status.onlineTypes.includes("local")) {
+        status.onlineType = "local";
+    }
+    else {
+        status.onlineType = "unknown";
+    }
+    if (!isOnline) {
+        if (isSleep()) {
+            status.type = "sleep";
         }
     }
     if (status.type === "sleep") {
@@ -247,8 +235,7 @@ export const initState = async () => {
     ]);
     config.imageAngle = rotateInfo.angle;
     config.videoAngle = rotateInfo.actualAngle;
-    fetchDeviceProperties().catch(() => {
-    });
+    fetchDeviceProperties();
     getDeviceAdvancedAbilities();
     syncRemoteSerectKey();
     setTimeout(() => {

package/lib/sync/user.js

@@ -1,44 +1,8 @@
 import { getDeviceStatus } from "../state";
 import { ProductCommunicationType } from "../constant";
 import config, { hasCapability } from "../config";
-import { getUsersSyncLockData, removeUser } from "../api/user";
-import dpCodes from "../config/dp-code";
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../config/dp-map/unlock-method-big";
-import { remove as removeMap, reportRemove as reportRemoveMap, } from "../config/dp-map/unlock-method";
-import { publishDps } from "../utils/publishDps";
-const deleteUser = async (data) => {
-    const { admin, lockUserId, userId } = data;
-    const dpCode = config.supportBigData
-        ? dpCodes.unlockMethodDelW
-        : dpCodes.unlockMethodDel;
-    const dpData = {
-        type: 0,
-        stage: 0,
-        admin: !!admin,
-        memberId: lockUserId,
-        unlockId: config.supportBigData ? 0xffff : 0xff,
-        category: 0,
-    };
-    await publishDps({
-        [dpCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
-    }, {
-        checkReport: (dps) => {
-            if (dps[dpCode]) {
-                const dpValue = dpUtils.parse(dps[dpCode], (config.supportBigData
-                    ? reportRemoveBigMap
-                    : reportRemoveMap));
-                if (dpValue.type === 0 &&
-                    dpValue.status == 255 &&
-                    dpValue.memberId === lockUserId) {
-                    return true;
-                }
-            }
-            return false;
-        },
-    });
-    await removeUser(config.devInfo.devId, userId);
-};
+import { getUsersSyncLockData } from "../api/user";
+import { deleteUser } from "../utils/user";
 let isSyncDone = false;
 const syncDeleteUsers = async () => {
     const deviceStatus = getDeviceStatus();

package/lib/temporary.d.ts

@@ -7,8 +7,9 @@ interface CreateCustomParams {
 export declare const createTempCustom: (params: CreateCustomParams) => Promise<TempPasswordResult>;
 interface RemoveCustomProps {
     unlockBindingId: string;
+    sn: number;
 }
-export declare const removeTempCustom: (params: RemoveCustomProps) => Promise<unknown>;
+export declare const removeTempCustom: (params: RemoveCustomProps) => Promise<true | undefined>;
 interface UpdateTempPasswordParams {
     unlockBindingId: string;
     name: string;

package/lib/temporary.js

@@ -4,8 +4,8 @@ import { formatWeek, isUseNearChannel, parallelOnly, parseOfflinePassword, parse
 import { LoopTypes } from "./utils/constant";
 import { encrypt } from "./utils/device";
 import { getError } from "./utils/errors";
-import { addTempPwd as addTempPwdDpMap, reportAddTempPwd as reportAddTempPwdDpMap, } from "./config/dp-map/unlock-method";
-import { addTempPwd as addTempPwdBigDpMap, reportAddTempPwd as reportAddTempPwdDBigpMap, } from "./config/dp-map/unlock-method-big";
+import { addTempPwd as addTempPwdDpMap, reportAddTempPwd as reportAddTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, reportRemoveTempPwd as reportRemoveTempPwdDpMap, } from "./config/dp-map/unlock-method";
+import { addTempPwd as addTempPwdBigDpMap, reportAddTempPwd as reportAddTempPwdDBigpMap, removeTempPwd as removeTempPwdBigDpMap, reportRemoveTempPwd as reportRemoveTempPwdBigDpMap, } from "./config/dp-map/unlock-method-big";
 import { publishDps } from "./utils/publishDps";
 import dpCodes from "./config/dp-code";
 import dpUtils from "@ray-js/tuya-dp-transform";
@@ -144,21 +144,49 @@ export const createTempCustom = parallelOnly(async (params) => {
             };
         }
         catch (error) {
-            throw handleError(error);
+            throw handleError(error?.innerError ?? error);
         }
     }
 });
 export const removeTempCustom = async (params) => {
     try {
-        return deleteTempPassword({
+        await deleteTempPassword({
             devId: config.devInfo.devId,
             unlockBindingId: params.unlockBindingId,
             symbolic: false,
             dpTunnel: 2,
         });
+        if (isUseNearChannel()) {
+            const dpCode = config.supportBigData
+                ? dpCodes.tempPwdDelW
+                : dpCodes.tempPwdDel;
+            const dpData = {
+                unlockId: params.sn,
+            };
+            const result = await publishDps({
+                [dpCode]: dpUtils.format(dpData, (config.supportBigData
+                    ? removeTempPwdBigDpMap
+                    : removeTempPwdDpMap)),
+            }, {
+                checkReport: (dpData) => {
+                    const reportData = dpData[dpCode];
+                    if (reportData) {
+                        const data = dpUtils.parse(reportData, (config.supportBigData
+                            ? reportRemoveTempPwdBigDpMap
+                            : reportRemoveTempPwdDpMap));
+                        return data;
+                    }
+                    return false;
+                },
+            });
+            if (result.status === 0) {
+                return true;
+            }
+            throw getError(1065);
+        }
     }
     catch (e) {
-        handleError(e);
+        handleError(e?.innerError ?? e);
     }
 };
 export const updateTempCustom = async (params) => {
@@ -192,7 +220,7 @@ export const updateTempCustom = async (params) => {
         });
     }
     catch (error) {
-        handleError(error);
+        handleError(error?.innerError ?? error);
     }
 };
 const getOfflinePassword = async (params) => {
@@ -204,7 +232,7 @@ const getOfflinePassword = async (params) => {
         };
     }
     catch (error) {
-        throw handleError(error);
+        throw handleError(error?.innerError ?? error);
     }
 };
 export const createTempLimit = async (params) => {
@@ -472,7 +500,7 @@ const changePasswordPhase = async (unlockBindingId, phase) => {
         });
     }
     catch (e) {
-        handleError(e);
+        handleError(e?.innerError ?? e);
     }
     return true;
 };
@@ -554,7 +582,7 @@ export const saveTempOnlineUnlimited = async (params) => {
         };
     }
     catch (error) {
-        throw handleError(error);
+        throw handleError(error?.innerError ?? error);
     }
 };
 export const createTempOffline = async (params) => {
@@ -612,7 +640,7 @@ export const removeTempOnlineUnlimited = async (id) => {
         });
     }
     catch (error) {
-        throw handleError(error);
+        throw handleError(error?.innerError ?? error);
     }
 };
 const onLinePasswordStatusMap = {
@@ -646,7 +674,7 @@ export const getTempOnlineUnlimitedList = async () => {
         return newPswList;
     }
     catch (error) {
-        throw handleError(error);
+        throw handleError(error?.innerError ?? error);
     }
 };
 const offlinePasswordTypeMap = {
@@ -665,7 +693,7 @@ export const getTempOfflineEffectiveList = async (pwdTypeCode) => {
         return offLineValidPswList;
     }
     catch (error) {
-        throw handleError(error);
+        throw handleError(error?.innerError ?? error);
     }
 };
 export const getTempOfflineInvalidList = async (pwdTypeCode) => {
@@ -678,6 +706,6 @@ export const getTempOfflineInvalidList = async (pwdTypeCode) => {
         return offLineFailurePswList;
     }
     catch (error) {
-        throw handleError(error);
+        throw handleError(error?.innerError ?? error);
     }
 };

package/lib/user.js

@@ -8,10 +8,12 @@ import DpUtils from "@ray-js/tuya-dp-transform";
 import { getError } from "./utils/errors";
 import { updateUserTimeSchedule, addNormalUser, removeNormalUser, } from "./api/user";
 import { validConfigDpMap } from "./config/dp-map/common";
-import { formatTimestampToMilliseconds, formatWeek, isAdmin, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
+import { formatTimestampToMilliseconds, formatWeek, getPermanentSetting, isAdmin, isUseNearChannel, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
 import { getCurrentHomeInfo, isSupportShortLink } from "./utils/device";
 import { LoopTypes } from "./utils/constant";
 import { getCurrentUser } from "./state";
+import { deleteUser } from "./utils/user";
+import { UserType } from "./constant";
 const concactUserList = (list, result) => {
     return list.reduce((acc, item) => {
         const { timeScheduleInfo, unlockDetail, ...rest } = item;
@@ -134,24 +136,22 @@ export const updateUserLimitTime = async (params) => {
         validNum: 0,
         pwdLength: 0,
         pwd: [],
-        validConfig: {
-            startTime: Math.floor(permanent ? +new Date() / 1000 : effective.effectiveDate),
-            endTime: Math.floor(permanent
-                ? (+new Date() + 3153600000000) / 1000
-                : effective.expiredDate),
-            loop: permanent ? LoopTypes.NONE : loopType,
-            loopConfig: 0,
-            weeks: permanent ||
-                effective?.repeat !== "week" ||
-                effective?.weeks === undefined
-                ? [0, 0, 0, 0, 0, 0, 0]
-                : effective.weeks,
-            days: [],
-            startHour: permanent ? 0 : Math.floor(effectiveTime / 60),
-            startMinute: permanent ? 0 : effectiveTime % 60,
-            endHour: permanent ? 0 : Math.floor(expiredTime / 60),
-            endMinute: permanent ? 0 : expiredTime % 60,
-        },
+        validConfig: permanent
+            ? getPermanentSetting()
+            : {
+                startTime: effective.effectiveDate,
+                endTime: effective.expiredDate,
+                loop: loopType,
+                loopConfig: 0,
+                weeks: effective?.repeat !== "week" || effective?.weeks === undefined
+                    ? [0, 0, 0, 0, 0, 0, 0]
+                    : effective.weeks,
+                days: [],
+                startHour: Math.floor(effectiveTime / 60),
+                startMinute: effectiveTime % 60,
+                endHour: Math.floor(expiredTime / 60),
+                endMinute: expiredTime % 60,
+            },
     };
     const dpCode = config.supportBigData
         ? dpCodes.unlockMethodEditW
@@ -268,6 +268,17 @@ export const removeUser = async (userId) => {
     if (!config.supportBigData) {
         throw getError(1060);
     }
+    const res = await getUserDetail({
+        devId: config.devInfo.devId,
+        userId,
+    });
+    if (isUseNearChannel()) {
+        return deleteUser({
+            userId,
+            lockUserId: res.lockUserId,
+            admin: res.userType === UserType.ADMIN || res.userType === UserType.OWNER,
+        });
+    }
     return removeNormalUser({
         devId: config.devInfo.devId,
         userId,

package/lib/utils/device.d.ts

@@ -5,6 +5,7 @@ export declare const setDeviceProperty: (devId: string, code: string, value: str
 export declare const publishDeviceDps: (params: {
     deviceId: string;
     dps: Record<string, boolean | number | string>;
+    pipelines?: number[];
 }) => Promise<unknown>;
 export declare const registerDevice: (devIds: string[]) => void;
 export declare const registerBleStatus: (devId: string) => void;

package/lib/utils/device.js

@@ -131,7 +131,7 @@ export const requestCloud = (options) => {
                 resolve(d);
             },
             fail: (err) => {
-                reject(err.innerError ?? err);
+                reject(err ?? err);
             },
         });
     });

package/lib/utils/errors.js

@@ -63,6 +63,7 @@ const errors = {
     1062: "Device does not support active connection",
     1063: "Password length only supports 4-6 digits",
     1064: "Non-thread device, not supported in LAN connection to open and close locks",
+    1065: "Cloud side has been deleted, but device side synchronization deletion failed",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {

package/lib/utils/index.js

@@ -64,7 +64,7 @@ export const getPermanentSetting = () => {
     const now = Math.floor(+new Date() / 1000);
     return {
         startTime: now,
-        endTime: now + 3153600000,
+        endTime: 0x72bc9b7f,
         loop: LoopTypes.NONE,
         loopConfig: 0,
         weeks: [0, 0, 0, 0, 0, 0, 0],

package/lib/utils/publishDps.js

@@ -7,7 +7,7 @@ import { getError } from "./errors";
 export const publishDpsOnly = async (dpData) => {
     const { devInfo, idsByCode } = config;
     const option = {};
-    if (config.onlineType === 0) {
+    if (config.deviceStatus.type === "offline") {
         throw getError(1001);
     }
     if (isOnlineByType(config.onlineType, 2)) {

package/lib/utils/user.d.ts

@@ -0,0 +1,2 @@
+import { RemovedUserData } from "../api/user";
+export declare const deleteUser: (data: RemovedUserData) => Promise<void>;

package/lib/utils/user.js

@@ -0,0 +1,39 @@
+import { removeUser } from "../api/user";
+import dpCodes from "../config/dp-code";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "../config/dp-map/unlock-method-big";
+import { remove as removeMap, reportRemove as reportRemoveMap, } from "../config/dp-map/unlock-method";
+import { publishDps } from "../utils/publishDps";
+import config from "../config";
+export const deleteUser = async (data) => {
+    const { admin, lockUserId, userId } = data;
+    const dpCode = config.supportBigData
+        ? dpCodes.unlockMethodDelW
+        : dpCodes.unlockMethodDel;
+    const dpData = {
+        type: 0,
+        stage: 0,
+        admin: !!admin,
+        memberId: lockUserId,
+        unlockId: config.supportBigData ? 0xffff : 0xff,
+        category: 0,
+    };
+    await publishDps({
+        [dpCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
+    }, {
+        checkReport: (dps) => {
+            if (dps[dpCode]) {
+                const dpValue = dpUtils.parse(dps[dpCode], (config.supportBigData
+                    ? reportRemoveBigMap
+                    : reportRemoveMap));
+                if (dpValue.type === 0 &&
+                    dpValue.status == 255 &&
+                    dpValue.memberId === lockUserId) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    });
+    await removeUser(config.devInfo.devId, userId);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.1.0",
+  "version": "1.1.1-beta.2",
   "files": [
     "lib",
     "LICENSE.md"

package/lib/dp-interface.d.ts

@@ -1,7 +0,0 @@
-export interface UpdateUserEffectiveData {
-    type: 0;
-    stage: number;
-    admin: boolean;
-    memberId: number;
-    unlockId: 255;
-}

package/lib/dp-interface.js

@@ -1 +0,0 @@
-export {};

package/lib/sync/unlock-mothod.d.ts

@@ -1,2 +0,0 @@
-export declare const syncUnlockMethod: () => Promise<void>;
-export declare const autoSyncUnlockMethod: () => Promise<void>;

package/lib/sync/unlock-mothod.js

@@ -1,42 +0,0 @@
-import { fetchSyncUnlockMethodInfo } from "../api/lock";
-import config from "../config";
-import dpCodes from "../config/dp-code";
-import { getCurrentUser } from "../state";
-import { publishDps } from "../utils/publishDps";
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { reportSync as reportSyncMap } from "../config/dp-map/unlock-method";
-import { reportSync as reportSyncBigMap } from "../config/dp-map/unlock-method-big";
-let syncUnlockMethodFirst = true;
-export const syncUnlockMethod = async () => {
-    syncUnlockMethodFirst = false;
-    const { allOpenDps = "" } = await getCurrentUser();
-    const { ins = "", distributed = false } = await fetchSyncUnlockMethodInfo({
-        devId: config.devInfo.devId,
-        dpIds: allOpenDps.split(","),
-    });
-    if (ins && distributed) {
-        const dpCode = config.supportBigData
-            ? dpCodes.synchMethodW
-            : dpCodes.synchMethod;
-        await publishDps({ [dpCode]: ins }, {
-            checkReport: (dpData) => {
-                if (typeof dpData[dpCode] !== "undefined") {
-                    const result = dpUtils.parse(dpData[dpCode], config.supportBigData ? reportSyncBigMap : reportSyncMap);
-                    if (result.stage === 1) {
-                        return true;
-                    }
-                }
-                return false;
-            },
-        });
-    }
-};
-export const autoSyncUnlockMethod = async () => {
-    try {
-        if (syncUnlockMethodFirst) {
-            await syncUnlockMethod();
-        }
-    }
-    catch (e) {
-    }
-};