@ray-js/lock-sdk 1.2.0-beta.24 → 1.2.0-beta.26

package/lib/feature/fit/temp-password.js

@@ -3,11 +3,13 @@ import dpCodes from "../../config/dp-code";
 import { fitAddTempPwd, fitReportAddTempPwd, fitRemoveTempPwd, fitReportRemoveTempPwd, fitUpdateTempPwd, fitReportUpdateTempPwd, fitBlePswCreate, fitBlePswDelete, fitBlePswCreateReport, fitBlePswDeleteReport, fitBlePswUpdate, fitBlePswUpdateReport, } from "../../config/dp-map/temp-pwd-fit";
 import { publishDpsForRuntime } from "../dp/publish-dps";
 import { resolveSlaveId } from "./resolve-slave-id";
-import { getError } from "../../utils/errors";
+import { getError, handleCloudError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
-import { addFitOnlineTempPwd, addFitOnlineTempPwdCloud, getFitPasswordList, removeFitOnlineTempPwd, renameFitOnlineTempPwd, updateFitOnlineTempPwd, } from "../../api/fit";
+import { addFitOnlineTempPwd, addFitOnlineTempPwdCloud, getFitPasswordList, removeFitOnlineTempPwd, renameFitOnlineTempPwd, resendFitOnlineTempPwd, updateFitOnlineTempPwd, } from "../../api/fit";
+import { reNameOfflineByPwdId, revokeOfflinePasswordByPwdId } from "../../api/temp";
 import { decrypt, encrypt } from "../../platform";
 import { formatPasswordToList, formatWeek, getAppUser, parseWeek, sleep, transformEffectiveConfigToValidConfig, validateEffectiveConfig, } from "../../utils";
+import { parseOfflinePasswordForRuntime } from "../utils";
 import { hasDpForRuntime } from "../dp/has-dp";
 export async function fitAddTempPwdForRuntime(runtime, params) {
     const startedAt = Date.now();
@@ -180,7 +182,7 @@ export async function fitRemoveTempPwdForRuntime(runtime, params) {
                 data: { id: params.id, status: res.status, strategy: "device_first" },
             });
             if (res.status === 0x00 || res.status === 0x02) {
-                await removeFitOnlineTempPwd(runtime.devId, exist.pwdId);
+                await removeFitOnlineTempPwd(runtime.devId, exist.unlockBindingId);
             }
             else {
                 throw getError(1028);
@@ -426,3 +428,93 @@ export const fitRenameTempPwdForRuntime = async (runtime, params) => {
         throw error;
     }
 };
+export const fitRenameOfflineTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "renameOfflineStart", {
+        devId: runtime.devId,
+        data: { pwdId: params.pwdId, hasName: typeof params.name === "string" },
+    });
+    try {
+        await reNameOfflineByPwdId({
+            devId: runtime.devId,
+            pwdName: params.name,
+            pwdId: params.pwdId,
+        });
+        sdkLog("info", "fitTempPassword", "renameOfflineSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "renameOfflineFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+            error,
+        });
+        throw error;
+    }
+};
+export const fitRevokeOfflineTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "revokeOfflineStart", {
+        devId: runtime.devId,
+        data: { pwdId: params.pwdId, hasName: typeof params.name === "string" },
+    });
+    try {
+        const res = await revokeOfflinePasswordByPwdId({
+            devId: runtime.devId,
+            pwdId: params.pwdId,
+            name: params.name,
+        });
+        sdkLog("info", "fitTempPassword", "revokeOfflineSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+        });
+        return {
+            password: parseOfflinePasswordForRuntime(runtime, res.pwd),
+            pwdId: res.pwdId,
+            name: res.pwdName,
+            effectiveConfig: {
+                effectiveDate: res.gmtStart,
+                expiredDate: res.gmtExpired,
+            },
+        };
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "revokeOfflineFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdId: params.pwdId },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+};
+export const fitResendTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "resendStart", {
+        devId: runtime.devId,
+        data: { id: params.id },
+    });
+    try {
+        const result = await resendFitOnlineTempPwd(runtime.devId, params.id);
+        sdkLog("info", "fitTempPassword", "resendSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "resendFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+};

package/lib/feature/fit/users.d.ts

@@ -7,6 +7,7 @@ export interface FitUserItem {
     nickName: string;
     userType: UserType;
     userContact: string;
+    userTimeSet: string;
     phase: number;
 }
 export declare function getFitUsersForRuntime(runtime: LockDeviceRuntime): Promise<FitUserItem[]>;

package/lib/feature/fit/users.js

@@ -7,6 +7,7 @@ const pickFitUserItem = (raw) => ({
     nickName: raw.nickName,
     userType: raw.userType,
     userContact: raw.userContact,
+    userTimeSet: raw.userTimeSet,
     phase: raw.phase,
 });
 export async function getFitUsersForRuntime(runtime) {

package/lib/feature/log/log.d.ts

@@ -1,5 +1,5 @@
 import { LockLogCategory } from "../../api/log";
-import { AlbumMessage, LogData, UnlockMethodType } from "../../interface";
+import { AlbumMessage, CloseValue, LogData, UnlockMethodType } from "../../interface";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export type LogsRefreshListener = () => void;
 export declare function getLogsRefreshEvent(runtime: LockDeviceRuntime): string;
@@ -16,11 +16,13 @@ export interface GetLogsParams {
     pageSize?: number;
 }
 export declare const openDps: ("unlock_matter_kw" | "unlock_password" | "unlock_fingerprint" | "unlock_finger_vein" | "unlock_hand" | "unlock_dynamic" | "unlock_key" | "unlock_card" | "unlock_face" | "unlock_temporary" | "unlock_offline_pd" | "unlock_phone_remote" | "unlock_voice_remote" | "lock_record" | "unlock_ble" | "unlock_eye" | "unlock_double_kit" | "unlock_double_kit_w" | "open_inside" | "lock_local_record" | "unlock_inside" | "door_opened" | "unlock_app")[];
+export declare const closeTypes: CloseValue[];
 export interface GetLogsResult {
     list: LogData[];
     hasMore: boolean;
     total: number;
 }
+export declare const dpIdsForUsernameToUnlockName: number[];
 export declare function getLogsForRuntime(rt: LockDeviceRuntime, params?: GetLogsParams): Promise<GetLogsResult>;
 export interface GetAlarmsParams {
     page?: number;
@@ -61,3 +63,5 @@ export interface GetLockLogListResult {
     lastRowKey: string;
 }
 export declare const getLockLogListForRuntime: (rt: LockDeviceRuntime, params: GetLockLogListParams) => Promise<GetLockLogListResult>;
+export declare const getAlarmUnreadCountForRuntime: (rt: LockDeviceRuntime) => Promise<number>;
+export declare const getActivePeriodForRuntime: (rt: LockDeviceRuntime) => Promise<number>;

package/lib/feature/log/log.js

@@ -1,4 +1,4 @@
-import { getAlarmList, getAlbumMessages, getLatest2Log, getLockLogList, getRecordList, } from "../../api/log";
+import { getAlarmList, getAlbumMessages, getLatest2Log, getLockLogList, getRecordList, getAlarmUnreadCountApi, getActivePeriodApi, } from "../../api/log";
 import dpCodes from "../../config/dp-code";
 import { getCurrentUserForRuntime } from "../user/current-user";
 import base64ToHex from "../../utils/base64-to-hex";
@@ -153,7 +153,7 @@ function handleLockLogs(list, cfg) {
             userId: item.userId,
             userName: userName || "",
             unlockName: unlockName || "",
-            mediaInfo: item.mediaInfoList?.map?.(item => {
+            mediaInfo: item.mediaInfoList?.map?.((item) => {
                 return {
                     mediaPath: item.mediaPath,
                     fileKey: item.fileKey,
@@ -241,7 +241,7 @@ export const openDps = [
     dpCodes.unlockApp,
     dpCodes.unlockMatterKw,
 ];
-const closeTypes = [
+export const closeTypes = [
     "UNDEFINED",
     "APP_REMOTE",
     "VOICE_REMOTE",
@@ -251,7 +251,7 @@ const closeTypes = [
     "AUTO",
     "LOCAL_MANUAL",
 ];
-const dpIdsForUsernameToUnlockName = [89, 69, 55, 67, 3, 32];
+export const dpIdsForUsernameToUnlockName = [89, 69, 55, 67, 3, 32];
 export async function getLogsForRuntime(rt, params) {
     const cfg = rt.config;
     const { page = 1, pageSize = 50 } = params || {};
@@ -468,3 +468,5 @@ export const getLockLogListForRuntime = async (rt, params) => {
         lastRowKey: data?.lastRowKey ?? "",
     };
 };
+export const getAlarmUnreadCountForRuntime = (rt) => getAlarmUnreadCountApi(rt.config.devInfo.devId);
+export const getActivePeriodForRuntime = (rt) => getActivePeriodApi(rt.config.devInfo.devId);

package/lib/feature/misc/connect-device.d.ts

@@ -1,2 +1,2 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
-export declare function connectDeviceForRuntime(rt: LockDeviceRuntime): Promise<true>;
+export declare function connectDeviceForRuntime(rt: LockDeviceRuntime, timeout?: number): Promise<true>;

package/lib/feature/misc/connect-device.js

@@ -72,7 +72,7 @@ const awakeDevice = async (devId, timeout) => {
         run();
     });
 };
-const connectBle = async (devId) => {
+const connectBle = async (devId, timeout) => {
     const startedAt = Date.now();
     sdkLog("info", "connectDevice", "bleConnectStart", { devId });
     return new Promise((resolve, reject) => {
@@ -109,7 +109,7 @@ const connectBle = async (devId) => {
                     error,
                 });
                 reject(error);
-            }, 15000);
+            }, timeout ?? 15000);
             const clearTimer = () => {
                 clearTimeout(timer);
                 offBleChange(handleStatusChange);
@@ -143,7 +143,7 @@ const connectBle = async (devId) => {
         });
     });
 };
-export async function connectDeviceForRuntime(rt) {
+export async function connectDeviceForRuntime(rt, timeout) {
     const cfg = rt.config;
     const devId = cfg.devInfo.devId;
     const deviceStatus = getDeviceStatusForRuntime(rt);
@@ -160,7 +160,7 @@ export async function connectDeviceForRuntime(rt) {
     });
     if (deviceStatus.connectEnable && hasWirelessAwakeDp) {
         if (cfg.devInfo.isCloudOnline && !getDpValueForRuntime(rt, wirelessAwake)) {
-            const result = await awakeDevice(devId);
+            const result = await awakeDevice(devId, timeout);
             sdkLog("info", "connectDevice", "success", {
                 devId,
                 duration: Date.now() - startedAt,
@@ -179,7 +179,7 @@ export async function connectDeviceForRuntime(rt) {
             });
             return true;
         }
-        await connectBle(devId);
+        await connectBle(devId, timeout);
         if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
             if (rt.cache.deviceAdvanceAbilityCache?.yuChannel.value === 1) {
                 yuChannelSyncSingleSync(devId);

package/lib/feature/password/temporary/offline-create.d.ts

@@ -1,7 +1,21 @@
+import { type LimitOfflinePwdItem, type OfflinePwdAvailableResult } from "../../../api/temp";
 import type { TempPasswordResult } from "../../../interface";
 import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
 import type { CreateClearParams, CreateLimitParams, CreateOnceParams } from "./types";
 export declare function createTempLimitForRuntime(rt: LockDeviceRuntime, params: CreateLimitParams): Promise<TempPasswordResult>;
 export declare function createTempOnceForRuntime(rt: LockDeviceRuntime, params: CreateOnceParams): Promise<TempPasswordResult>;
+export interface FitOfflineOnceResult {
+    password: string;
+    pwdId: string;
+    gmtExpired: number;
+}
+export declare function createFitOfflineOnceForRuntime(rt: LockDeviceRuntime): Promise<FitOfflineOnceResult>;
+export declare function createFitOfflineLimitForRuntime(rt: LockDeviceRuntime, params: {
+    effectiveTime: number;
+    invalidTime: number;
+}): Promise<FitOfflineOnceResult>;
+export declare function createFitOfflineClearAllForRuntime(rt: LockDeviceRuntime): Promise<FitOfflineOnceResult>;
+export declare function getFitOfflineRevocableListForRuntime(rt: LockDeviceRuntime): Promise<LimitOfflinePwdItem[]>;
+export declare function getFitOfflinePwdAvailableForRuntime(rt: LockDeviceRuntime, pwdType: string): Promise<OfflinePwdAvailableResult>;
 export declare function createTempDynamicForRuntime(rt: LockDeviceRuntime): Promise<TempPasswordResult>;
 export declare function createTempClearForRuntime(rt: LockDeviceRuntime, params: CreateClearParams): Promise<TempPasswordResult>;

package/lib/feature/password/temporary/offline-create.js

@@ -1,4 +1,4 @@
-import { getDynamicPassword, revokeOfflinePassword, } from "../../../api/temp";
+import { createOfflineOnceAPI, getDynamicPassword, getLimitOfflinePwdListForClear, getOfflinePwdAvailable, revokeOfflinePassword, } from "../../../api/temp";
 import { parseOfflinePasswordForRuntime } from "../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { getOfflinePassword } from "./internal/password-helpers";
@@ -87,6 +87,82 @@ export async function createTempOnceForRuntime(rt, params) {
         },
     };
 }
+async function createFitOfflinePwdForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createFitOfflinePwdStart", {
+        devId: rt.devId,
+        data: { pwdType: params.pwdType },
+    });
+    try {
+        const res = await createOfflineOnceAPI({
+            devId: rt.devId,
+            ...params,
+        });
+        sdkLog("info", "tempPassword", "createFitOfflinePwdSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdType: params.pwdType },
+        });
+        return {
+            password: parseOfflinePasswordForRuntime(rt, res.pwd),
+            pwdId: res.pwdId,
+            gmtExpired: res.gmtExpired,
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "createFitOfflinePwdFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { pwdType: params.pwdType },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export function createFitOfflineOnceForRuntime(rt) {
+    return createFitOfflinePwdForRuntime(rt, {
+        pwdType: "1",
+        gmtStart: "0",
+        gmtExpired: "0",
+    });
+}
+export function createFitOfflineLimitForRuntime(rt, params) {
+    const { effectiveTime, invalidTime } = params;
+    if (effectiveTime >= invalidTime) {
+        throw getError(1010);
+    }
+    return createFitOfflinePwdForRuntime(rt, {
+        pwdType: "0",
+        gmtStart: String(effectiveTime),
+        gmtExpired: String(invalidTime),
+    });
+}
+export function createFitOfflineClearAllForRuntime(rt) {
+    return createFitOfflinePwdForRuntime(rt, {
+        pwdType: "9",
+        gmtStart: "0",
+        gmtExpired: "0",
+    });
+}
+export async function getFitOfflineRevocableListForRuntime(rt) {
+    try {
+        return (await getLimitOfflinePwdListForClear({ devId: rt.devId })) || [];
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getFitOfflinePwdAvailableForRuntime(rt, pwdType) {
+    try {
+        return await getOfflinePwdAvailable({
+            devId: rt.config.devInfo.devId,
+            pwdType,
+        });
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
 export async function createTempDynamicForRuntime(rt) {
     const startedAt = Date.now();
     sdkLog("info", "tempPassword", "createDynamicStart", {

package/lib/feature/state/clear.js

@@ -8,6 +8,7 @@ export function clearStateForRuntime(runtime) {
     runtime.cache.currentUser = null;
     runtime.cache.offlineDpCache = undefined;
     runtime.cache.deviceAdvanceAbilityCache = undefined;
+    runtime.cache.fitDeviceBvCache = undefined;
     runtime.cache.isActiveThreadCache = false;
     runtime.sync.hasSyncedT0 = false;
     runtime.sync.syncDeleteUsersBusy = false;

package/lib/feature/state/platform-routing.js

@@ -3,6 +3,7 @@ import { getRuntimeByDevId, listRegisteredRuntimes, } from "../../runtime/regist
 import emitter from "../../utils/event";
 import { getWiFiSignalChangeEvent } from "../misc/signal";
 import { autoSyncTemp } from "../password/sync-temp";
+import { syncFitBindingsForRuntime } from "../fit/sync";
 import syncT0 from "./sync/t0";
 import syncRemoteSerectKey from "./sync/remote-serect-key";
 import { syncOfflineDps } from "./sync/offline-dps";
@@ -93,6 +94,9 @@ const globalHandleBleChange = ({ deviceId, status }) => {
     if (rt) {
         updateOnlineType(rt);
         if (status === "CONNECTED") {
+            if (rt.config.isFitting) {
+                syncFitBindingsForRuntime(rt).catch(() => { });
+            }
             void syncRemoteSerectKey(rt);
             autoSyncTemp(rt);
             void syncT0(rt);

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

@@ -11,6 +11,13 @@ import { reportSetKey as reportSetKeyMap, setKey as setKeyMap, } from "../../../
 import { sdkLog } from "../../../utils/sdk-log";
 const syncRemoteSerectKey = async (runtime, force) => {
     const rt = runtime;
+    if (rt.config.isFitting || !rt.config.idsByCode[dpCodes.remoteNoPdSetkey]) {
+        sdkLog("debug", "syncKey", "skipped", {
+            devId: rt.devId,
+            data: { reason: "unsupported", force: !!force },
+        });
+        return;
+    }
     const useNear = isUseNearChannelForRuntime(rt);
     if (!useNear) {
         sdkLog("debug", "syncKey", "skipped", {

package/lib/feature/unlock/method/add-flow.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { parallelOnlyForRuntime } from "../../utils";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import emitter from "../../../utils/event";
@@ -207,7 +207,7 @@ const handleAddReport = async (dps) => {
                         const res = await createUnlockMethod({
                             devId: cfg.devInfo.devId,
                             userId: addUnlockMethodData.userId,
-                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                            unlockId: formatCloudUnlockId(addUnlockMethodData.unlockDpId, result.unlockId),
                             unlockName: "",
                             unlockAttr: 0,
                         });

package/lib/feature/unlock/method/add-password.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { encrypt } from "../../../platform/device";
-import { sleep } from "../../../utils";
+import { formatCloudUnlockId, sleep } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import { getUnlockMethodBase } from "./internal/base";
@@ -76,7 +76,7 @@ export async function addPasswordForRuntime(rt, params) {
         const result = await createUnlockMethod({
             devId: devId,
             userId: params.userId,
-            unlockId: `${dpId}-${res.unlockId}`,
+            unlockId: formatCloudUnlockId(dpId, res.unlockId),
             unlockName: params.name,
             unlockDetail: aesPwd,
             ...specialInfo,

package/lib/feature/utils/index.d.ts

@@ -1,5 +1,6 @@
 import type { UnlockMethodConfig } from "../../interface";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const unlockMethodDpCodes: string[];
 export declare const getUnlockMethodTypeByDpCodeForRuntime: (rt: LockDeviceRuntime, dpCode: string) => UnlockMethodConfig;
 export declare const getUnlockMethodTypeByIdForRuntime: (rt: LockDeviceRuntime, id: number | string) => UnlockMethodConfig;
 export declare const getUnlockMethodTypeByTypeForRuntime: (rt: LockDeviceRuntime, type: string) => UnlockMethodConfig;

package/lib/feature/utils/index.js

@@ -33,6 +33,7 @@ const unlockMethodConfigs = [
         id: 6,
     },
 ];
+export const unlockMethodDpCodes = unlockMethodConfigs.reduce((res, item) => res.concat(item.codes), []);
 const getUnlockMethodTypeForRuntime = (rt, cb) => {
     const result = unlockMethodConfigs.find(cb);
     if (result) {

package/lib/interface.d.ts

@@ -182,6 +182,16 @@ export interface EffectiveConfig {
     effectiveTime?: number;
     expiredTime?: number;
 }
+export interface FitBleKeyItem {
+    id: string;
+    unlockBindingId: string;
+    name: string;
+    opModeSubType?: number;
+    effectiveConfig: EffectiveConfig;
+    sn?: number;
+    userName?: string;
+    devNameList?: string[];
+}
 export interface UnBindUnlockMethod {
     dpId: number;
     dpCode: string;
@@ -276,6 +286,8 @@ export interface LogData {
     dpCode: string;
     data: any;
     userName: string;
+    avatarUrl?: string;
+    relateDevName?: string;
     bindable: boolean;
     unlockName: string;
     mediaInfo?: MediaInfo[];

package/lib/runtime/LockDeviceRuntime.js

@@ -14,6 +14,7 @@ export class LockDeviceRuntime {
             offlineDpCache: undefined,
             isActiveThreadCache: false,
             deviceAdvanceAbilityCache: undefined,
+            fitDeviceBvCache: undefined,
         };
         this.sync = {
             hasSyncedT0: false,
@@ -21,6 +22,8 @@ export class LockDeviceRuntime {
             unlockMethodAutoSyncEnabled: true,
             tempAutoSyncEnabled: true,
             tempPayloadSyncing: false,
+            fitSyncReportHandler: null,
+            fitBindingsSyncStarted: false,
         };
         this.infra = {
             eventsRegistered: false,

package/lib/runtime/lock-config.d.ts

@@ -26,6 +26,7 @@ export type LockConfigState = {
     isTwoWayTalk: boolean;
     cameraConfig: CameraConfig[];
     notSupportWake: boolean;
+    isFitting: boolean;
 };
 export declare function createDefaultDeviceStatus(): DeviceStatus;
 export declare function createLockConfigState(): LockConfigState;

package/lib/runtime/lock-config.js

@@ -35,6 +35,7 @@ export function createLockConfigState() {
         supportTalk: false,
         isTwoWayTalk: false,
         cameraConfig: [],
-        notSupportWake: false
+        notSupportWake: false,
+        isFitting: false
     };
 }

package/lib/runtime/runtime-state-types.d.ts

@@ -5,6 +5,7 @@ export interface LockRuntimeCacheFields {
     offlineDpCache: OfflineDps | undefined;
     isActiveThreadCache: boolean;
     deviceAdvanceAbilityCache: DeviceAdvancedAbility | undefined;
+    fitDeviceBvCache: Promise<number> | undefined;
 }
 export interface LockRuntimeSyncFlags {
     hasSyncedT0: boolean;
@@ -12,6 +13,11 @@ export interface LockRuntimeSyncFlags {
     unlockMethodAutoSyncEnabled: boolean;
     tempAutoSyncEnabled: boolean;
     tempPayloadSyncing: boolean;
+    fitSyncReportHandler: ((data: {
+        deviceId?: string;
+        data?: string;
+    }) => void) | null;
+    fitBindingsSyncStarted: boolean;
 }
 export interface LockRuntimeInfraFields {
     eventsRegistered: boolean;

package/lib/utils/index.d.ts

@@ -121,6 +121,7 @@ export declare function getCapabilities(capability: number): ({
     readonly short: "thread";
 })[];
 export declare const formatWeek: (value: number[]) => number;
+export declare const formatCloudUnlockId: (dpId: number | string, sn: number) => string;
 export declare const parseWeek: (value: number) => Week;
 export declare const getPermanentSetting: () => {
     startTime: number;

package/lib/utils/index.js

@@ -56,6 +56,7 @@ export const formatWeek = (value) => {
     const temp = value.slice(0, 7);
     return parseInt(temp.reverse().join(""), 2);
 };
+export const formatCloudUnlockId = (dpId, sn) => `${dpId}-${sn.toString(16).padStart(2, "0")}`;
 export const parseWeek = (value) => {
     return Number(value)
         .toString(2)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.2.0-beta.24",
+  "version": "1.2.0-beta.26",
   "files": [
     "lib",
     "LICENSE.md"