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

package/lib/state.js

@@ -1,351 +0,0 @@
-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";
-import emitter from "./utils/event";
-import { DPCHANGE, LOGCHANGE } from "./utils/constant";
-import dpCodes, { latLogDpCodes } from "./config/dp-code";
-import { getCurrentUserInfo } from "./api/user";
-import { equels, getDataWithPreFetch, isOnlineByType } from "./utils";
-import { getRotateInfo } from "./api/video";
-import syncT0 from "./sync/t0";
-import syncRemoteSerectKey from "./sync/remote-serect-key";
-import { autoSyncUnlockMethod } from "./sync/unlock-method";
-import { autoSyncTemp, handleBleSyncRequestReport } from "./sync/temp";
-import { DEVICE_STATUS_CHANGE_EVENT, SLEEP_EVENT } from "./event";
-import { getSleepPeriod, isSleep } from "./sleep";
-import { ProductCommunicationType } from "./constant";
-import { getDeviceAdvancedAbilities, isShareThead } from "./capability";
-import { isSupportBleControl } from "./other";
-import syncDeleteUsers from "./sync/user";
-import { syncOfflineDps } from "./sync/offline-dps";
-import { checkOfflineDpUpdate } from "./offline-dps";
-let dpState = {};
-let logRefreshTimer = 0;
-export const clearState = () => {
-    dpState = {};
-};
-export const getDpValue = (code) => {
-    return dpState[code];
-};
-const updateOnlineType = async () => {
-    const [devInfo, onlineType] = await Promise.all([
-        getDeviceInfo(config.devInfo.devId),
-        getDeviceOnlineType(config.devInfo.devId),
-    ]);
-    config.onlineType = onlineType;
-    config.devInfo = devInfo;
-    updateDeviceStatus();
-};
-export const getDeviceStatus = () => {
-    const { onlineType, devInfo: { isCloudOnline, isOnline, wifiEnableState, isMatter }, } = config;
-    const supportWifi = hasCapability(ProductCommunicationType.WIFI);
-    const supportBle = hasCapability(ProductCommunicationType.BLUETOOTH);
-    const supportThread = hasCapability(ProductCommunicationType.THREAD);
-    const status = {
-        type: isOnline ? "online" : "offline",
-        connectEnable: false,
-        onlineType: "unknown",
-        onlineTypes: [],
-        isWifiActive: wifiEnableState !== 1,
-        isWifiMatter: !!isMatter && supportWifi,
-    };
-    const isBleOnline = isOnlineByType(onlineType, 2);
-    const isMatterLocal = isOnlineByType(onlineType, 8);
-    const isLocalOnline = !isCloudOnline && isOnlineByType(onlineType, 1);
-    const hasWirelessAwakeDp = hasDp(dpCodes.wirelessAwake);
-    const wirelessAwake = getDpValue(dpCodes.wirelessAwake);
-    status.connectEnable = isSupportBleControl() && !isOnline;
-    if (supportWifi) {
-        if (!status.connectEnable) {
-            if (isCloudOnline) {
-                status.connectEnable =
-                    hasWirelessAwakeDp && wirelessAwake === false && !isBleOnline;
-            }
-        }
-    }
-    if (isOnline) {
-        if (isCloudOnline) {
-            if (hasWirelessAwakeDp) {
-                if (wirelessAwake) {
-                    status.onlineTypes.push("cloud");
-                }
-                else {
-                    status.type = "offline";
-                }
-            }
-            else {
-                status.onlineTypes.push("cloud");
-            }
-        }
-        if (isLocalOnline) {
-            status.onlineTypes.push("local");
-        }
-        if (isMatterLocal) {
-            if (!status.onlineTypes.includes("local")) {
-                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) {
-            if (!status.onlineTypes.includes("local")) {
-                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") {
-        if (getDpValue(dpCodes.dormantSwitch) || getDpValue(dpCodes.onlineSwitch)) {
-            status.sleepPeriod = getSleepPeriod();
-        }
-    }
-    return status;
-};
-const updateDeviceStatus = () => {
-    const status = getDeviceStatus();
-    if (!equels(config.deviceStatus, status)) {
-        config.deviceStatus = status;
-        emitter.emit(DEVICE_STATUS_CHANGE_EVENT, status);
-    }
-    if (status.type === "online") {
-        syncDeleteUsers();
-    }
-};
-const handleDpChange = (dps, notEmit) => {
-    let refleshLogsEnabled = false;
-    const dpData = Object.keys(dps).reduce((acc, key) => {
-        const code = config.codesById[key];
-        if (code) {
-            acc[code] = dps[key];
-            if (!refleshLogsEnabled && latLogDpCodes.includes(code)) {
-                refleshLogsEnabled = true;
-            }
-        }
-        return acc;
-    }, {});
-    if (dpData[dpCodes.deviceInfo]) {
-        config.capabilities = parseCapabilities(dpData[dpCodes.deviceInfo]);
-    }
-    Object.assign(dpState, dpData);
-    if (!notEmit) {
-        emitter.emit(DPCHANGE, dpData);
-        if (typeof dpData[dpCodes.linkMode] !== "undefined") {
-            emitter.emit(SLEEP_EVENT, {
-                sleep: isSleep(),
-            });
-        }
-        if (refleshLogsEnabled) {
-            clearTimeout(logRefreshTimer);
-            logRefreshTimer = setTimeout(() => {
-                emitter.emit(LOGCHANGE, dpData);
-            }, 2000);
-        }
-        checkOfflineDpUpdate(dpData);
-        if (typeof dpData[dpCodes.bleSyncRequest] !== "undefined") {
-            handleBleSyncRequestReport(dpData[dpCodes.bleSyncRequest]);
-        }
-    }
-};
-const handleDeviceDpsChange = ({ dps, deviceId, }) => {
-    if (deviceId === config.devInfo.devId) {
-        handleDpChange(dps);
-        updateDeviceStatus();
-    }
-};
-const handleDeviceInfoChange = ({ dps, deviceId, }) => {
-    if (deviceId === config.devInfo.devId && dps) {
-        handleDpChange(dps);
-    }
-    updateOnlineType();
-    updateDeviceStatus();
-};
-let currentUser = null;
-export const getCurrentUser = async (isForce) => {
-    if (currentUser && !isForce) {
-        return currentUser;
-    }
-    if (isForce) {
-        currentUser = await getCurrentUserInfo(config.devInfo.devId);
-    }
-    else {
-        currentUser = await getDataWithPreFetch("getCurrentUser", () => getCurrentUserInfo(config.devInfo.devId));
-    }
-    currentUser.allOpenDps = currentUser.allOpenDps || "";
-    return currentUser;
-};
-export const getCurrentUserSync = () => {
-    return currentUser;
-};
-export const getMediaRotate = () => {
-    return {
-        imageAngle: config.imageAngle,
-        videoAngle: config.videoAngle,
-    };
-};
-export const permissions = [
-    "adminsOnly",
-    "everyOne",
-    "noOne",
-];
-var DeviceProperties;
-(function (DeviceProperties) {
-    DeviceProperties["REMOTE_UNLOCK_AUTH"] = "REMOTE_UNLOCK_AUTH";
-    DeviceProperties["UNLOCK_PHONE_REMOTE"] = "UNLOCK_PHONE_REMOTE";
-})(DeviceProperties || (DeviceProperties = {}));
-const propsList = [
-    DeviceProperties.REMOTE_UNLOCK_AUTH,
-    DeviceProperties.UNLOCK_PHONE_REMOTE,
-];
-const fetchDeviceProperties = async (isForce) => {
-    let result = null;
-    if (isForce) {
-        result = await getDeviceProperties(config.devInfo.devId, propsList);
-    }
-    else {
-        result = await getDataWithPreFetch("getDeviceProperties", () => {
-            return getDeviceProperties(config.devInfo.devId, propsList);
-        });
-    }
-    config.remoteOpenEnabled =
-        result[DeviceProperties.UNLOCK_PHONE_REMOTE] === "true";
-    config.remoteOpenPermission =
-        permissions[+result[DeviceProperties.REMOTE_UNLOCK_AUTH] || 0];
-};
-export const initState = async () => {
-    const { devInfo: { dps, devId }, dpSchema, } = config;
-    handleDpChange(dps, true);
-    const isSupportVideo = !!dpSchema[dpCodes.initiativeMessage];
-    config.deviceStatus = getDeviceStatus();
-    const [, , rotateInfo] = await Promise.all([
-        updateOnlineType(),
-        getCurrentUser(),
-        isSupportVideo
-            ? getDataWithPreFetch("getRotate", () => getRotateInfo(devId))
-            : Promise.resolve({
-                angle: 0,
-                actualAngle: 0,
-            }),
-    ]);
-    config.imageAngle = rotateInfo.angle;
-    config.videoAngle = rotateInfo.actualAngle;
-    fetchDeviceProperties();
-    getDeviceAdvancedAbilities();
-    syncRemoteSerectKey();
-    checkOfflineDpUpdate({}, true).then(() => {
-        setTimeout(() => {
-            syncOfflineDps();
-        }, 3000);
-    });
-    setTimeout(() => {
-        syncT0();
-        autoSyncUnlockMethod();
-    }, 2000);
-    setTimeout(() => {
-        autoSyncTemp();
-        syncDeleteUsers();
-    }, 3000);
-};
-const handleMqttMessage = ({ deviceId, messageData, protocol }) => {
-    const { devId } = config.devInfo;
-    if (devId === deviceId) {
-        switch (+protocol) {
-            case 23: {
-                if (messageData?.data?.signal || messageData?.data?.signal === 0) {
-                    const signal = messageData.data.signal;
-                    let signalText = "bad";
-                    if (signal > -50) {
-                        signalText = "good";
-                    }
-                    else if (signal <= -50 && signal > -65) {
-                        signalText = "normal";
-                    }
-                    else if (signal <= -65 && signal > -75) {
-                        signalText = "weak";
-                    }
-                    emitter.emit("onWiFiSignalChange", {
-                        signal,
-                        level: signalText,
-                    });
-                }
-                break;
-            }
-        }
-    }
-};
-let hasEvent = false;
-const handleBleChange = ({ deviceId, status }) => {
-    if (deviceId === config.devInfo.devId && status === "CONNECTED") {
-        syncRemoteSerectKey();
-        autoSyncTemp();
-        syncT0();
-        syncOfflineDps();
-    }
-};
-const handleAppShow = () => {
-    getCurrentUser(true);
-    fetchDeviceProperties();
-    checkOfflineDpUpdate({}, true);
-    setTimeout(() => {
-        syncDeleteUsers();
-    }, 1000);
-};
-const handleAppHide = () => { };
-export const addEvents = () => {
-    if (hasEvent) {
-        return;
-    }
-    const { devId } = config.devInfo;
-    hasEvent = true;
-    registerDevice([devId]);
-    registerBleStatus(devId);
-    registerMQTTDeviceListener(devId);
-    registerMQTTProtocolListener(23);
-    onMqttMessage(handleMqttMessage);
-    onDpDataChange(handleDeviceDpsChange);
-    onDeviceInfoUpdated(handleDeviceInfoChange);
-    onOnlineChange(updateOnlineType);
-    onBleChange(handleBleChange);
-    onAppShow(handleAppShow);
-    onAppHide(handleAppHide);
-};
-export const removeEvents = () => {
-    if (hasEvent) {
-        return;
-    }
-    hasEvent = false;
-    offDpDataChange(handleDeviceDpsChange);
-    offDeviceInfoUpdated(handleDeviceInfoChange);
-    offOnlineChange(updateOnlineType);
-    offBleChange(handleBleChange);
-    offMqttMessage(handleMqttMessage);
-};
-export const onDeviceStatusChange = (callback) => {
-    emitter.on(DEVICE_STATUS_CHANGE_EVENT, callback);
-};
-export const offDeviceStatusChange = (callback) => {
-    emitter.off(DEVICE_STATUS_CHANGE_EVENT, callback);
-};

package/lib/sync/ble-temp-payload.d.ts

@@ -1,2 +0,0 @@
-import { SyncTempPwdItem } from "../api/temp";
-export declare function buildBleTempPwdSyncPayload(pwdList: SyncTempPwdItem[]): Promise<string>;

package/lib/sync/offline-dps.d.ts

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

package/lib/sync/offline-dps.js

@@ -1,29 +0,0 @@
-import { clearOfflineDpData } from "../api";
-import { getOfflineDps } from "../offline-dps";
-import config from "../config";
-import { isUseNearChannel } from "../utils";
-import { publishDpsOnly } from "../utils/publishDps";
-export const syncOfflineDps = async () => {
-    if (config.supportOfflineDps) {
-        const useNear = isUseNearChannel();
-        if (useNear) {
-            const offlineDps = await getOfflineDps();
-            try {
-                if (Object.keys(offlineDps).length) {
-                    const hasTask = Object.keys(offlineDps).some((code) => offlineDps[code].pushStatus === false);
-                    if (hasTask) {
-                        clearOfflineDpData(config.devInfo.devId);
-                        const dpData = Object.keys(offlineDps).reduce((acc, code) => {
-                            acc[code] = offlineDps[code].value;
-                            return acc;
-                        }, {});
-                        publishDpsOnly(dpData);
-                    }
-                }
-            }
-            catch (error) {
-                console.warn(error);
-            }
-        }
-    }
-};

package/lib/sync/remote-serect-key.d.ts

@@ -1,2 +0,0 @@
-declare const syncRemoteSerectKey: (force?: boolean) => Promise<void>;
-export default syncRemoteSerectKey;

package/lib/sync/remote-serect-key.js

@@ -1,43 +0,0 @@
-import { checkRemoteKey } from "../api/lock";
-import config from "../config";
-import dpCodes from "../config/dp-code";
-import { getCurrentUser, getDpValue } from "../state";
-import { isUseNearChannel } from "../utils";
-import { stringToBytes } from "../utils/byte";
-import { decrypt } from "../utils/device";
-import { publishDpsOnly } from "../utils/publishDps";
-import dpUtils from "@ray-js/tuya-dp-transform";
-import { reportSetKey as reportSetKeyMap, setKey as setKeyMap, } from "../config/dp-map/open";
-const syncRemoteSerectKey = async (force) => {
-    const useNear = isUseNearChannel();
-    if (useNear) {
-        try {
-            if (!force) {
-                const keyValue = getDpValue(dpCodes.remoteNoPdSetkey);
-                if (keyValue) {
-                    const keyData = dpUtils.parse(getDpValue(dpCodes.remoteNoPdSetkey), reportSetKeyMap);
-                    if (keyData.status === 0) {
-                        return;
-                    }
-                }
-            }
-            const { lockUserId, userId } = await getCurrentUser();
-            const { password, invalidTime, effectiveTime } = await checkRemoteKey(config.devInfo.devId);
-            const pw = await decrypt(config.devInfo.devId, password);
-            publishDpsOnly({
-                [dpCodes.remoteNoPdSetkey]: dpUtils.format({
-                    valid: true,
-                    memberId: lockUserId !== 0 ? lockUserId : userId,
-                    startTime: effectiveTime,
-                    endTime: invalidTime,
-                    validNum: 100,
-                    key: stringToBytes(pw),
-                }, setKeyMap),
-            });
-        }
-        catch (e) {
-            console.warn(e);
-        }
-    }
-};
-export default syncRemoteSerectKey;

package/lib/sync/t0.d.ts

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

package/lib/sync/t0.js

@@ -1,26 +0,0 @@
-import { getActiveTime } from "../api";
-import config, { hasCapability } from "../config";
-import dpCodes from "../config/dp-code";
-import { ProductCommunicationType } from "../constant";
-import { isUseNearChannel } from "../utils";
-import { publishDpsOnly } from "../utils/publishDps";
-let hasSysncT0 = false;
-const isNeedSync = () => {
-    const near = isUseNearChannel();
-    return (near ||
-        (config.devInfo.isOnline &&
-            hasCapability(ProductCommunicationType.THREAD)));
-};
-const syncT0 = async () => {
-    if (hasSysncT0) {
-        return;
-    }
-    if (config.dpSchema[dpCodes.passwordOfflineTime]) {
-        if (isNeedSync()) {
-            hasSysncT0 = true;
-            const time = await getActiveTime(config.devInfo.devId);
-            publishDpsOnly({ [dpCodes.passwordOfflineTime]: time.toString() });
-        }
-    }
-};
-export default syncT0;

package/lib/sync/temp.d.ts

@@ -1,3 +0,0 @@
-export declare const notifyBleSyncRequest: () => Promise<void>;
-export declare const autoSyncTemp: () => void;
-export declare const handleBleSyncRequestReport: (rawValue: string) => Promise<void>;

package/lib/sync/temp.js

@@ -1,70 +0,0 @@
-import { getSyncTempPasswords } from "../api/temp";
-import config, { hasDp } from "../config";
-import dpCodes from "../config/dp-code";
-import { bleSyncRequest as bleSyncRequestMap, reportBleSyncRequest as reportBleSyncRequestMap, } from "../config/dp-map/ble-sync";
-import { isUseNearChannel, parallelOnly } from "../utils";
-import { publishBLETransparentData } from "../utils/device";
-import { publishDpsOnly } from "../utils/publishDps";
-import { buildBleTempPwdSyncPayload } from "./ble-temp-payload";
-import dpUtils from "@ray-js/tuya-dp-transform";
-const CMD_REQUEST_SYNC = 0x01;
-const DATA_TYPE_TEMP_PWD = 0x01;
-const NOTIFY_DEBOUNCE_MS = 2000;
-let notifyTimer = null;
-let isSyncingPayload = false;
-const hasBleSyncDp = () => hasDp(dpCodes.bleSyncRequest);
-const publishBleSyncNotify = async (hasPending) => {
-    await publishDpsOnly({
-        [dpCodes.bleSyncRequest]: dpUtils.format({ cmd: hasPending ? 0x01 : 0x00 }, bleSyncRequestMap),
-    });
-};
-export const notifyBleSyncRequest = parallelOnly(async () => {
-    if (!isUseNearChannel() || !hasBleSyncDp()) {
-        return;
-    }
-    const { count } = await getSyncTempPasswords({
-        devId: config.devInfo.devId,
-        isUpt: false,
-    });
-    await publishBleSyncNotify(count > 0);
-});
-export const autoSyncTemp = () => {
-    if (!isUseNearChannel() || !hasBleSyncDp()) {
-        return;
-    }
-    if (notifyTimer) {
-        clearTimeout(notifyTimer);
-    }
-    notifyTimer = setTimeout(() => {
-        notifyTimer = null;
-        notifyBleSyncRequest().catch((e) => {
-            console.warn("ble_sync_request notify error", e);
-        });
-    }, NOTIFY_DEBOUNCE_MS);
-};
-export const handleBleSyncRequestReport = async (rawValue) => {
-    if (!hasBleSyncDp() || !isUseNearChannel() || isSyncingPayload) {
-        return;
-    }
-    const report = dpUtils.parse(rawValue, reportBleSyncRequestMap);
-    if (report.cmd !== CMD_REQUEST_SYNC || report.dataType !== DATA_TYPE_TEMP_PWD) {
-        return;
-    }
-    isSyncingPayload = true;
-    try {
-        const { count, pwdList } = await getSyncTempPasswords({
-            devId: config.devInfo.devId,
-            isUpt: false,
-        });
-        if (count > 0 && pwdList?.length) {
-            const payload = await buildBleTempPwdSyncPayload(pwdList);
-            await publishBLETransparentData(config.devInfo.devId, payload);
-        }
-    }
-    catch (e) {
-        console.warn("ble_sync_request data transfer error", e);
-    }
-    finally {
-        isSyncingPayload = false;
-    }
-};

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

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

package/lib/sync/unlock-method.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;
-        try {
-            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;
-                },
-            });
-        }
-        catch (error) {
-        }
-    }
-};
-export const autoSyncUnlockMethod = async () => {
-    if (syncUnlockMethodFirst) {
-        await syncUnlockMethod();
-    }
-};

package/lib/sync/user.d.ts

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

package/lib/sync/user.js

@@ -1,68 +0,0 @@
-import { getDeviceStatus } from "../state";
-import config from "../config";
-import { getUsersSyncLockData } from "../api/user";
-import { deleteUser } from "../utils/user";
-import { isUseNearChannel } from "../utils";
-let isSyncing = false;
-const syncDeleteUsers = async () => {
-    const deviceStatus = getDeviceStatus();
-    if (deviceStatus.isWifiActive) {
-        return;
-    }
-    if (deviceStatus.isWifiMatter) {
-        return;
-    }
-    if (!isUseNearChannel()) {
-        return;
-    }
-    if (isSyncing)
-        return;
-    isSyncing = true;
-    let count = 0;
-    const handleSync = async () => {
-        try {
-            const { removedUser = [] } = await getUsersSyncLockData(config.devInfo.devId);
-            const deleteSerialCollectFailures = async (users) => {
-                const failed = [];
-                for (const item of users) {
-                    try {
-                        await deleteUser(item);
-                    }
-                    catch {
-                        failed.push(item);
-                    }
-                }
-                return failed;
-            };
-            let failed = await deleteSerialCollectFailures(removedUser);
-            if (failed.length > 0) {
-                failed = await deleteSerialCollectFailures(failed);
-                if (failed.length > 0 && count < 3) {
-                    count++;
-                    setTimeout(async () => {
-                        await handleSync();
-                    }, 2000);
-                }
-                else {
-                    isSyncing = false;
-                }
-            }
-            else {
-                isSyncing = false;
-            }
-        }
-        catch (e) {
-            if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
-                count++;
-                setTimeout(async () => {
-                    await handleSync();
-                }, 2000);
-            }
-            else {
-                isSyncing = false;
-            }
-        }
-    };
-    handleSync();
-};
-export default syncDeleteUsers;