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

package/lib/api/temp.js

@@ -2,6 +2,7 @@ import { requestApi } from "./request";
 import { THING } from "../utils/constant";
 export const createTemporaryPassword = (params) => {
     return requestApi({
+        logName: "createTemporaryPassword",
         api: `${THING}.m.device.lock.temppwd.create`,
         version: "8.0",
         data: params,
@@ -9,6 +10,7 @@ export const createTemporaryPassword = (params) => {
 };
 export const createOnlineUnlimited = (params) => {
     return requestApi({
+        logName: "createOnlineUnlimited",
         api: `${THING}.m.device.lock.temppwd.create`,
         version: "4.0",
         data: params,
@@ -16,6 +18,7 @@ export const createOnlineUnlimited = (params) => {
 };
 export const validateTempPwd = async (params) => {
     return requestApi({
+        logName: "validateTempPwd",
         api: `${THING}.m.device.lock.temppwd.validate`,
         version: "3.0",
         data: params,
@@ -23,6 +26,7 @@ export const validateTempPwd = async (params) => {
 };
 export const updateTemporaryPassword = (params) => {
     return requestApi({
+        logName: "updateTemporaryPassword",
         api: `${THING}.m.device.lock.temppwd.update`,
         version: "4.0",
         data: params,
@@ -30,6 +34,7 @@ export const updateTemporaryPassword = (params) => {
 };
 export const getTempPassword = (params) => {
     return requestApi({
+        logName: "getTempPassword",
         api: `${THING}.m.device.lock.temppwd.detail`,
         version: "1.0",
         data: params,
@@ -37,6 +42,7 @@ export const getTempPassword = (params) => {
 };
 export const deleteTempPassword = (params) => {
     return requestApi({
+        logName: "deleteTempPassword",
         api: `${THING}.m.device.lock.temppwd.remove`,
         version: "5.0",
         data: params,
@@ -44,6 +50,7 @@ export const deleteTempPassword = (params) => {
 };
 export const removeTempOnlineUnlimitedAPI = (params) => {
     return requestApi({
+        logName: "removeTempOnlineUnlimitedAPI",
         api: `${THING}.m.device.lock.temppwd.del`,
         version: "2.0",
         data: params,
@@ -51,6 +58,7 @@ export const removeTempOnlineUnlimitedAPI = (params) => {
 };
 export const getTempOnlineUnlimitedListAPI = (devId) => {
     return requestApi({
+        logName: "getTempOnlineUnlimitedListAPI",
         api: `${THING}.m.device.lock.temppwd.list`,
         version: "2.0",
         data: {
@@ -60,6 +68,7 @@ export const getTempOnlineUnlimitedListAPI = (devId) => {
 };
 export const getTempOfflineListAPI = (params) => {
     return requestApi({
+        logName: "getTempOfflineListAPI",
         api: `${THING}.m.device.lock.offlinepwd.list`,
         version: "1.0",
         data: params,
@@ -67,6 +76,7 @@ export const getTempOfflineListAPI = (params) => {
 };
 export const createOfflinePassword = (params) => {
     return requestApi({
+        logName: "createOfflinePassword",
         api: `${THING}.m.device.lock.offlinepwd.get`,
         version: "3.0",
         data: params,
@@ -74,6 +84,7 @@ export const createOfflinePassword = (params) => {
 };
 export const createOfflineOnceAPI = (params) => {
     return requestApi({
+        logName: "createOfflineOnceAPI",
         api: `${THING}.m.device.lock.offlinepwd.get`,
         version: "1.0",
         data: params,
@@ -81,6 +92,7 @@ export const createOfflineOnceAPI = (params) => {
 };
 export const getDynamicPassword = (params) => {
     return requestApi({
+        logName: "getDynamicPassword",
         api: `${THING}.m.device.lock.dynapwd.get`,
         version: "3.0",
         data: params,
@@ -88,6 +100,7 @@ export const getDynamicPassword = (params) => {
 };
 export const revokeOfflinePassword = (params) => {
     return requestApi({
+        logName: "revokeOfflinePassword",
         api: `${THING}.m.device.lock.offlinepwd.revoke`,
         version: "2.0",
         data: params,
@@ -95,6 +108,7 @@ export const revokeOfflinePassword = (params) => {
 };
 export const fetchEffectiveList = (params) => {
     return requestApi({
+        logName: "fetchEffectiveList",
         api: `${THING}.m.device.lock.auth.list`,
         version: "1.0",
         data: params,
@@ -102,6 +116,7 @@ export const fetchEffectiveList = (params) => {
 };
 export const fetchInvalidList = (params) => {
     return requestApi({
+        logName: "fetchInvalidList",
         api: `${THING}.m.device.lock.auth.list.invalid`,
         version: "1.0",
         data: params,
@@ -109,6 +124,7 @@ export const fetchInvalidList = (params) => {
 };
 export const clearInvalidTempList = (params) => {
     return requestApi({
+        logName: "clearInvalidTempList",
         api: `${THING}.m.device.lock.auth.list.clear`,
         version: "1.0",
         data: params,
@@ -116,6 +132,7 @@ export const clearInvalidTempList = (params) => {
 };
 export const reNameTemporary = (params) => {
     return requestApi({
+        logName: "reNameTemporary",
         api: `${THING}.m.device.lock.temppwd.name`,
         version: "1.0",
         data: params,
@@ -123,6 +140,7 @@ export const reNameTemporary = (params) => {
 };
 export const reNameOffline = (params) => {
     return requestApi({
+        logName: "reNameOffline",
         api: `${THING}.m.device.lock.offlinepwd.name.update`,
         version: "2.0",
         data: params,
@@ -130,8 +148,17 @@ export const reNameOffline = (params) => {
 };
 export const getSyncTempPasswords = (params) => {
     return requestApi({
+        logName: "getSyncTempPasswords",
         api: "m.lock.device.lock.tempwd.sync",
         version: "1.0",
         data: params,
     });
 };
+export const getLimitOfflinePwdListForClear = (params) => {
+    return requestApi({
+        logName: "getLimitOfflinePwdList",
+        api: `${THING}.m.device.lock.offlinepwd.revocable`,
+        version: "1.0",
+        data: params,
+    });
+};

package/lib/api/user.d.ts

@@ -1,5 +1,14 @@
 import { CurrentUser } from "../interface";
 export declare const getCurrentUserInfo: (deviceId: string) => Promise<CurrentUser>;
+export interface UserAuthListMeItem {
+    availTime?: number;
+    unlockBindingId?: string;
+}
+interface GetUserAuthListParams {
+    devId: string;
+    authTypes: string[];
+}
+export declare const getuserAuthList: (params: GetUserAuthListParams) => Promise<UserAuthListMeItem[]>;
 interface UserTimeScheduleParams {
     devId: string;
     userId: string;
@@ -98,15 +107,40 @@ interface GetUsersSyncLockResponse {
         devUnlockId: string;
         distributed: boolean;
         ins: string;
+        wakeUpIns: string;
     };
     lockFitting: {
         dpId: number;
         distributed: boolean;
-        ins: Array<any>;
+        ins: Array<string>;
     };
     lockRecord: string;
     removedUser: Array<RemovedUserData>;
 }
 export declare const getUsersSyncLockData: (deviceId: string) => Promise<GetUsersSyncLockResponse>;
 export declare const removeUser: (devId: string, userId: string) => Promise<unknown>;
+export interface LockShareAvailableParams {
+    unlockBindingId?: number | string;
+    devId: string;
+    availTime: number;
+    countryCode: string;
+    account: string;
+    name?: string;
+    effectiveTime: number;
+    invalidTime: number;
+    schedule?: {
+        allDay: boolean;
+        effectiveTime: number;
+        invalidTime: number;
+        workingDay: number;
+    }[];
+}
+export interface LockShareAvailableResult {
+    validateResult: boolean;
+    registered?: boolean;
+    dialogueType: number;
+    errorMsg: string;
+    errorCode: string;
+}
+export declare const checkLockShareAvailable: (params: LockShareAvailableParams) => Promise<LockShareAvailableResult>;
 export {};

package/lib/api/user.js

@@ -2,6 +2,7 @@ import { THING } from "../utils/constant";
 import { requestApi } from "./request";
 export const getCurrentUserInfo = (deviceId) => {
     return requestApi({
+        logName: "getCurrentUserInfo",
         api: `${THING}.m.device.member.get`,
         version: "3.0",
         data: {
@@ -10,8 +11,17 @@ export const getCurrentUserInfo = (deviceId) => {
         },
     });
 };
+export const getuserAuthList = (params) => {
+    return requestApi({
+        logName: "getuserAuthList",
+        api: "m.lock.auth.list.me",
+        version: "1.0",
+        data: params,
+    });
+};
 export const updateUserTimeSchedule = (params) => {
     return requestApi({
+        logName: "updateUserTimeSchedule",
         api: `${THING}.m.device.user.time.schedule.update`,
         version: "1.0",
         data: params,
@@ -19,6 +29,7 @@ export const updateUserTimeSchedule = (params) => {
 };
 export const addNormalUser = async (params) => {
     return requestApi({
+        logName: "addNormalUser",
         api: "m.smart.scale.history.user.add",
         version: "1.0",
         data: params,
@@ -26,6 +37,7 @@ export const addNormalUser = async (params) => {
 };
 export const removeNormalUser = async (params) => {
     return requestApi({
+        logName: "removeNormalUser",
         api: "m.smart.scale.history.user.delete",
         version: "2.0",
         data: params,
@@ -33,6 +45,7 @@ export const removeNormalUser = async (params) => {
 };
 export const getUserList = (params) => {
     return requestApi({
+        logName: "getUserList",
         api: "m.lock.member.family.panel.all.list",
         version: "1.0",
         data: params,
@@ -40,6 +53,7 @@ export const getUserList = (params) => {
 };
 export const getUserDetailQuery = (params) => {
     return requestApi({
+        logName: "getUserDetailQuery",
         api: "m.lock.user.detail.query",
         version: "1.0",
         data: params,
@@ -47,6 +61,7 @@ export const getUserDetailQuery = (params) => {
 };
 export const getUsersSyncLockData = (deviceId) => {
     return requestApi({
+        logName: "getUsersSyncLockData",
         api: `${THING}.m.device.lock.sync.batch`,
         version: "1.0",
         data: {
@@ -56,6 +71,7 @@ export const getUsersSyncLockData = (deviceId) => {
 };
 export const removeUser = (devId, userId) => {
     return requestApi({
+        logName: "removeUser",
         api: `${THING}.m.device.member.remove`,
         version: "1.0",
         data: {
@@ -64,3 +80,11 @@ export const removeUser = (devId, userId) => {
         },
     });
 };
+export const checkLockShareAvailable = (params) => {
+    return requestApi({
+        logName: "checkLockShareAvailable",
+        api: `${THING}.m.device.lock.share.available`,
+        version: "1.0",
+        data: { ...params },
+    });
+};

package/lib/api/video.d.ts

@@ -2,3 +2,30 @@ export declare const getRotateInfo: (deviceId: string) => Promise<{
     angle: number;
     actualAngle: number;
 }>;
+interface DeviceSkillResult {
+    devid: string;
+    json: {
+        videos: [
+            {
+                width: number;
+                height: number;
+            }
+        ];
+        audios: [
+            {
+                channel: number;
+                codecType: number;
+                dataBit: number;
+                sampleRate: number;
+            }
+        ];
+    };
+}
+export declare const getDeviceSkill: (devId: string) => Promise<DeviceSkillResult>;
+export declare const getIPCConfig: (devId: string) => Promise<{
+    audioAttributes: {
+        callMode: number[];
+        hardwareCapability: number[];
+    };
+}>;
+export {};

package/lib/api/video.js

@@ -2,6 +2,7 @@ import { THING } from "../utils/constant";
 import { requestApi } from "./request";
 export const getRotateInfo = (deviceId) => {
     return requestApi({
+        logName: "getRotateInfo",
         api: `${THING}.m.device.lock.media.rotate.get`,
         version: "1.0",
         data: {
@@ -9,3 +10,23 @@ export const getRotateInfo = (deviceId) => {
         },
     });
 };
+export const getDeviceSkill = (devId) => {
+    return requestApi({
+        logName: "getDeviceSkill",
+        api: "m.lock.ipc.config.skill",
+        version: "1.0",
+        data: {
+            devId,
+        },
+    });
+};
+export const getIPCConfig = (devId) => {
+    return requestApi({
+        logName: "getIPCConfig",
+        api: "m.ipc.v4.rtc.config.get",
+        version: "1.0",
+        data: {
+            devId,
+        },
+    });
+};

package/lib/api/voice-file.d.ts

@@ -0,0 +1,14 @@
+export interface VoiceFileItem {
+    fileType: number;
+    fileKey: string;
+    fileStatus: number;
+    version: string;
+}
+export declare const getVoiceFileListApi: (devId: string) => Promise<VoiceFileItem[]>;
+export interface VoiceFileDownloadUrlResult {
+    url: string;
+}
+export declare const getVoiceFileDownloadUrlApi: (params: {
+    devId: string;
+    fileKey: string;
+}) => Promise<VoiceFileDownloadUrlResult>;

package/lib/api/voice-file.js

@@ -0,0 +1,18 @@
+import { THING } from "../utils/constant";
+import { requestApi } from "./request";
+export const getVoiceFileListApi = (devId) => {
+    return requestApi({
+        logName: "getVoiceFileList",
+        api: `${THING}.m.device.lock.voice.list`,
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const getVoiceFileDownloadUrlApi = (params) => {
+    return requestApi({
+        logName: "getVoiceFileDownloadUrl",
+        api: `${THING}.m.device.lock.voice.download`,
+        version: "1.0",
+        data: params,
+    });
+};

package/lib/bootstrap/bootstrap-lock-instance.d.ts

@@ -0,0 +1,7 @@
+import type { LockSDKOption } from "../interface";
+import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
+import { type LockSDKInstance } from "../entries/main/build-instance";
+export declare function bootstrapRegisteredLockInstance(options?: LockSDKOption): Promise<{
+    runtime: LockDeviceRuntime;
+    instance: LockSDKInstance;
+}>;

package/lib/bootstrap/bootstrap-lock-instance.js

@@ -0,0 +1,16 @@
+import { addEvents } from "../feature/state/platform-routing";
+import { initState } from "../feature/state/init-state";
+import { registerRuntime } from "../runtime/registry";
+import { buildLockSDKInstance, } from "../entries/main/build-instance";
+import * as MainDeviceExports from "../entries/main/exports";
+import { createBootstrappedRuntime } from "./bootstrap";
+export async function bootstrapRegisteredLockInstance(options) {
+    const runtime = await createBootstrappedRuntime(options);
+    registerRuntime(runtime);
+    addEvents(runtime);
+    await initState(runtime);
+    return {
+        runtime,
+        instance: buildLockSDKInstance(runtime, MainDeviceExports),
+    };
+}

package/lib/bootstrap/bootstrap.d.ts

@@ -0,0 +1,4 @@
+import type { LockSDKOption } from "../interface";
+import { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
+export declare function applyLockOptionsToRuntime(runtime: LockDeviceRuntime, options?: LockSDKOption): Promise<void>;
+export declare function createBootstrappedRuntime(options?: LockSDKOption): Promise<LockDeviceRuntime>;

package/lib/bootstrap/bootstrap.js

@@ -0,0 +1,53 @@
+import dpCodes from "../config/dp-code";
+import { getCapabilities } from "../utils";
+import { getDeviceInfo, trackEvent } from "../platform/device";
+import { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
+export async function applyLockOptionsToRuntime(runtime, options) {
+    const { config } = runtime;
+    let { devInfo, deviceId } = options || {};
+    if (!devInfo && !deviceId) {
+        throw new Error("deviceId is required in lock sdk");
+    }
+    if (deviceId && (!devInfo || devInfo.devId !== deviceId)) {
+        devInfo = await getDeviceInfo(deviceId);
+    }
+    let dpSchema = {};
+    const codesById = {};
+    const idsByCode = {};
+    if (devInfo.schema) {
+        dpSchema = devInfo.schema.reduce((acc, cur) => {
+            acc[cur.code] = cur;
+            codesById[cur.id] = cur.code;
+            idsByCode[cur.code] = cur.id;
+            return acc;
+        }, {});
+    }
+    else if (devInfo.dpSchema) {
+        dpSchema = devInfo.dpSchema;
+        Object.keys(dpSchema).forEach((key) => {
+            const item = dpSchema[key];
+            codesById[item.id] = item.code;
+            idsByCode[item.code] = item.id;
+        });
+    }
+    config.strictMode = options?.strictMode ?? true;
+    config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
+    config.passwordSupportZero = options?.passwordSupportZero ?? true;
+    config.supportMultipleFace = options?.supportMultipleFace ?? false;
+    config.supportOfflineDps = options?.supportOfflineDps ?? false;
+    config.devInfo = devInfo;
+    config.dpSchema = dpSchema;
+    config.codesById = codesById;
+    config.idsByCode = idsByCode;
+    config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
+    config.preFetch = options?.preFetch ?? false;
+    config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
+    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
+        pid: devInfo.productId,
+    });
+}
+export async function createBootstrappedRuntime(options) {
+    const runtime = new LockDeviceRuntime();
+    await applyLockOptionsToRuntime(runtime, options);
+    return runtime;
+}

package/lib/bootstrap/lock-instance-runtime-ref.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
+export declare function registerLockSDKInstanceRuntime(instance: object, runtime: LockDeviceRuntime): void;
+export declare function getRuntimeForLockSDKInstance(instance: object): LockDeviceRuntime | undefined;

package/lib/bootstrap/lock-instance-runtime-ref.js

@@ -0,0 +1,7 @@
+const runtimeByInstance = new WeakMap();
+export function registerLockSDKInstanceRuntime(instance, runtime) {
+    runtimeByInstance.set(instance, runtime);
+}
+export function getRuntimeForLockSDKInstance(instance) {
+    return runtimeByInstance.get(instance);
+}

package/lib/bootstrap/primary-instance.d.ts

@@ -0,0 +1,6 @@
+import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
+import type { LockSDKInstance } from "../entries/main/build-instance";
+export declare function setPrimaryLockSDKInstance(instance: LockSDKInstance): void;
+export declare function getPrimaryLockSDKRuntime(): LockDeviceRuntime | null;
+export declare function clearPrimaryLockSDKInstance(): void;
+export declare function clearPrimaryLockSDKInstanceIfDevId(devId: string): void;

package/lib/bootstrap/primary-instance.js

@@ -0,0 +1,24 @@
+import { getRuntimeForLockSDKInstance } from "./lock-instance-runtime-ref";
+let primaryDevId = null;
+let primaryRuntime = null;
+export function setPrimaryLockSDKInstance(instance) {
+    const runtime = getRuntimeForLockSDKInstance(instance);
+    if (!runtime) {
+        throw new Error("setPrimaryLockSDKInstance: instance must be returned by createLockSDK or init");
+    }
+    primaryDevId = runtime.devId;
+    primaryRuntime = runtime;
+}
+export function getPrimaryLockSDKRuntime() {
+    return primaryRuntime;
+}
+export function clearPrimaryLockSDKInstance() {
+    primaryDevId = null;
+    primaryRuntime = null;
+}
+export function clearPrimaryLockSDKInstanceIfDevId(devId) {
+    if (primaryDevId === devId) {
+        primaryDevId = null;
+        primaryRuntime = null;
+    }
+}

package/lib/bootstrap/resolve-runtime-from-export-this.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
+export type LockSdkBoundExportThis = {
+    devId: string;
+};
+export declare function resolveRuntimeFromExportThis(thisArg: unknown): LockDeviceRuntime;

package/lib/bootstrap/resolve-runtime-from-export-this.js

@@ -0,0 +1,29 @@
+import { getRuntimeByDevId } from "../runtime/registry";
+import { getRuntimeForLockSDKInstance } from "./lock-instance-runtime-ref";
+import { resolveTopLevelTargetRuntime } from "./top-level-runtime";
+export function resolveRuntimeFromExportThis(thisArg) {
+    if (thisArg !== null &&
+        thisArg !== undefined &&
+        typeof thisArg === "object") {
+        const rtFromInstance = getRuntimeForLockSDKInstance(thisArg);
+        if (rtFromInstance) {
+            return rtFromInstance;
+        }
+    }
+    if (thisArg !== null &&
+        thisArg !== undefined &&
+        typeof thisArg === "object" &&
+        "devId" in thisArg &&
+        typeof thisArg.devId === "string") {
+        const devId = thisArg.devId;
+        if (devId.length === 0) {
+            throw new Error("Lock SDK: bound context devId must be non-empty");
+        }
+        const rt = getRuntimeByDevId(devId);
+        if (!rt) {
+            throw new Error(`Lock SDK: no registered runtime for devId "${devId}"; use createLockSDK or init first`);
+        }
+        return rt;
+    }
+    return resolveTopLevelTargetRuntime();
+}

package/lib/bootstrap/top-level-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../runtime/LockDeviceRuntime";
+export declare function resolveTopLevelTargetRuntime(): LockDeviceRuntime;

package/lib/bootstrap/top-level-runtime.js

@@ -0,0 +1,9 @@
+import { getError } from "../utils/errors";
+import { getPrimaryLockSDKRuntime } from "./primary-instance";
+export function resolveTopLevelTargetRuntime() {
+    const primary = getPrimaryLockSDKRuntime();
+    if (!primary) {
+        throw getError(1071);
+    }
+    return primary;
+}