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

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

@@ -388,6 +388,89 @@ declare const addTempPwd: readonly [{
     readonly loop: true;
     readonly defaultValue: readonly [];
 }];
+declare const addBleTempPwd: readonly [{
+    readonly name: "type";
+    readonly bytes: 1;
+}, {
+    readonly name: "validConfig";
+    readonly type: "child";
+    readonly bytes: 17;
+    readonly childMap: readonly [{
+        readonly name: "startTime";
+        readonly bytes: 4;
+    }, {
+        readonly name: "endTime";
+        readonly bytes: 4;
+    }, {
+        readonly name: "loop";
+    }, {
+        readonly name: "loopConfig";
+        readonly condition: {
+            readonly type: "and";
+            readonly conditions: readonly [{
+                readonly prop: "validConfig.loop";
+                readonly value: 2;
+                readonly operation: "neq";
+            }, {
+                readonly prop: "loop";
+                readonly value: 3;
+                readonly operation: "neq";
+            }];
+        };
+        readonly bytes: 4;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "weeks";
+        readonly condition: {
+            readonly prop: "validConfig.loop";
+            readonly value: 2;
+        };
+        readonly type: "custom";
+        readonly bytes: 4;
+        readonly parse: (value: number) => number[];
+        readonly format: (value: number[]) => string;
+        readonly defaultValue: readonly [0, 0, 0, 0, 0, 0, 0];
+    }, {
+        readonly name: "days";
+        readonly condition: {
+            readonly prop: "validConfig.loop";
+            readonly value: 3;
+        };
+        readonly type: "bits";
+        readonly bytes: 4;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "startHour";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "startMinute";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "endHour";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "endMinute";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }];
+}, {
+    readonly name: "validNum";
+}, {
+    readonly name: "pwdLength";
+}, {
+    readonly name: "pwd";
+    readonly type: "number";
+    readonly limit: "pwdLength";
+    readonly loop: true;
+    readonly defaultValue: readonly [];
+}];
 declare const reportAddTempPwd: readonly [{
     readonly name: "cloudNo";
     readonly bytes: 2;
@@ -396,6 +479,11 @@ declare const reportAddTempPwd: readonly [{
 }, {
     readonly name: "status";
 }];
+declare const reportAddBleTempPwd: readonly [{
+    readonly name: "unlockId";
+}, {
+    readonly name: "status";
+}];
 declare const removeTempPwd: DpMap;
 declare const reportRemoveTempPwd: DpMap;
 declare const updateTempPwd: ({
@@ -482,10 +570,94 @@ declare const updateTempPwd: ({
     name: string;
     type: string;
 })[];
+declare const updateBleTempPwd: ({
+    readonly name: "validConfig";
+    readonly type: "child";
+    readonly bytes: 17;
+    readonly childMap: readonly [{
+        readonly name: "startTime";
+        readonly bytes: 4;
+    }, {
+        readonly name: "endTime";
+        readonly bytes: 4;
+    }, {
+        readonly name: "loop";
+    }, {
+        readonly name: "loopConfig";
+        readonly condition: {
+            readonly type: "and";
+            readonly conditions: readonly [{
+                readonly prop: "validConfig.loop";
+                readonly value: 2;
+                readonly operation: "neq";
+            }, {
+                readonly prop: "loop";
+                readonly value: 3;
+                readonly operation: "neq";
+            }];
+        };
+        readonly bytes: 4;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "weeks";
+        readonly condition: {
+            readonly prop: "validConfig.loop";
+            readonly value: 2;
+        };
+        readonly type: "custom";
+        readonly bytes: 4;
+        readonly parse: (value: number) => number[];
+        readonly format: (value: number[]) => string;
+        readonly defaultValue: readonly [0, 0, 0, 0, 0, 0, 0];
+    }, {
+        readonly name: "days";
+        readonly condition: {
+            readonly prop: "validConfig.loop";
+            readonly value: 3;
+        };
+        readonly type: "bits";
+        readonly bytes: 4;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "startHour";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "startMinute";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "endHour";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }, {
+        readonly name: "endMinute";
+        readonly type: "number";
+        readonly bytes: 1;
+        readonly defaultValue: 0;
+    }];
+} | {
+    readonly name: "pwdLength";
+} | {
+    readonly name: "pwd";
+    readonly type: "number";
+    readonly limit: "pwdLength";
+    readonly loop: true;
+    readonly defaultValue: readonly [];
+} | {
+    name: string;
+    bytes?: undefined;
+} | {
+    name: string;
+    bytes: number;
+})[];
 declare const reportUpdateTempPwd: DpMap;
 declare const sync: DpMap;
 declare const reportSync: DpMap;
-export { add, reportAdd, remove, reportRemove, update, updateMemberRole, reportUpdate, addTempPwd, reportAddTempPwd, removeTempPwd, reportRemoveTempPwd, updateTempPwd, reportUpdateTempPwd, sync, reportSync, };
+export { add, reportAdd, remove, reportRemove, update, updateMemberRole, reportUpdate, addTempPwd, addBleTempPwd, reportAddTempPwd, reportAddBleTempPwd, removeTempPwd, reportRemoveTempPwd, updateTempPwd, updateBleTempPwd, reportUpdateTempPwd, sync, reportSync, };
 declare const _default: {
     add: readonly [{
         readonly name: "type";
@@ -876,6 +1048,89 @@ declare const _default: {
         readonly loop: true;
         readonly defaultValue: readonly [];
     }];
+    addBleTempPwd: readonly [{
+        readonly name: "type";
+        readonly bytes: 1;
+    }, {
+        readonly name: "validConfig";
+        readonly type: "child";
+        readonly bytes: 17;
+        readonly childMap: readonly [{
+            readonly name: "startTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "endTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "loop";
+        }, {
+            readonly name: "loopConfig";
+            readonly condition: {
+                readonly type: "and";
+                readonly conditions: readonly [{
+                    readonly prop: "validConfig.loop";
+                    readonly value: 2;
+                    readonly operation: "neq";
+                }, {
+                    readonly prop: "loop";
+                    readonly value: 3;
+                    readonly operation: "neq";
+                }];
+            };
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "weeks";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 2;
+            };
+            readonly type: "custom";
+            readonly bytes: 4;
+            readonly parse: (value: number) => number[];
+            readonly format: (value: number[]) => string;
+            readonly defaultValue: readonly [0, 0, 0, 0, 0, 0, 0];
+        }, {
+            readonly name: "days";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 3;
+            };
+            readonly type: "bits";
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }];
+    }, {
+        readonly name: "validNum";
+    }, {
+        readonly name: "pwdLength";
+    }, {
+        readonly name: "pwd";
+        readonly type: "number";
+        readonly limit: "pwdLength";
+        readonly loop: true;
+        readonly defaultValue: readonly [];
+    }];
     reportAddTempPwd: readonly [{
         readonly name: "cloudNo";
         readonly bytes: 2;
@@ -884,6 +1139,11 @@ declare const _default: {
     }, {
         readonly name: "status";
     }];
+    reportAddBleTempPwd: readonly [{
+        readonly name: "unlockId";
+    }, {
+        readonly name: "status";
+    }];
     removeTempPwd: DpMap;
     reportRemoveTempPwd: DpMap;
     updateTempPwd: ({
@@ -970,6 +1230,90 @@ declare const _default: {
         name: string;
         type: string;
     })[];
+    updateBleTempPwd: ({
+        readonly name: "validConfig";
+        readonly type: "child";
+        readonly bytes: 17;
+        readonly childMap: readonly [{
+            readonly name: "startTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "endTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "loop";
+        }, {
+            readonly name: "loopConfig";
+            readonly condition: {
+                readonly type: "and";
+                readonly conditions: readonly [{
+                    readonly prop: "validConfig.loop";
+                    readonly value: 2;
+                    readonly operation: "neq";
+                }, {
+                    readonly prop: "loop";
+                    readonly value: 3;
+                    readonly operation: "neq";
+                }];
+            };
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "weeks";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 2;
+            };
+            readonly type: "custom";
+            readonly bytes: 4;
+            readonly parse: (value: number) => number[];
+            readonly format: (value: number[]) => string;
+            readonly defaultValue: readonly [0, 0, 0, 0, 0, 0, 0];
+        }, {
+            readonly name: "days";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 3;
+            };
+            readonly type: "bits";
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }];
+    } | {
+        readonly name: "pwdLength";
+    } | {
+        readonly name: "pwd";
+        readonly type: "number";
+        readonly limit: "pwdLength";
+        readonly loop: true;
+        readonly defaultValue: readonly [];
+    } | {
+        name: string;
+        bytes?: undefined;
+    } | {
+        name: string;
+        bytes: number;
+    })[];
     reportUpdateTempPwd: DpMap;
     sync: DpMap;
     reportSync: DpMap;

package/lib/config/dp-map/unlock-method.js

@@ -129,6 +129,17 @@ const addTempPwd = [
     },
     ...pwdConfigDpMap,
 ];
+const addBleTempPwd = [
+    {
+        name: "type",
+        bytes: 1,
+    },
+    validConfigDpMap,
+    {
+        name: "validNum",
+    },
+    ...pwdConfigDpMap,
+];
 const reportAddTempPwd = [
     {
         name: "cloudNo",
@@ -141,6 +152,14 @@ const reportAddTempPwd = [
         name: "status",
     },
 ];
+const reportAddBleTempPwd = [
+    {
+        name: "unlockId",
+    },
+    {
+        name: "status",
+    },
+];
 const removeTempPwd = [
     {
         name: "unlockId",
@@ -168,6 +187,20 @@ const updateTempPwd = [
     },
     ...pwdConfigDpMap,
 ];
+const updateBleTempPwd = [
+    {
+        name: "unlockId",
+    },
+    {
+        name: "type",
+        bytes: 1,
+    },
+    validConfigDpMap,
+    {
+        name: "validNum",
+    },
+    ...pwdConfigDpMap,
+];
 const reportUpdateTempPwd = [
     {
         name: "unlockId",
@@ -227,7 +260,7 @@ const reportSync = [
         ],
     },
 ];
-export { add, reportAdd, remove, reportRemove, update, updateMemberRole, reportUpdate, addTempPwd, reportAddTempPwd, removeTempPwd, reportRemoveTempPwd, updateTempPwd, reportUpdateTempPwd, sync, reportSync, };
+export { add, reportAdd, remove, reportRemove, update, updateMemberRole, reportUpdate, addTempPwd, addBleTempPwd, reportAddTempPwd, reportAddBleTempPwd, removeTempPwd, reportRemoveTempPwd, updateTempPwd, updateBleTempPwd, reportUpdateTempPwd, sync, reportSync, };
 export default {
     add,
     reportAdd,
@@ -237,10 +270,13 @@ export default {
     updateMemberRole,
     reportUpdate,
     addTempPwd,
+    addBleTempPwd,
     reportAddTempPwd,
+    reportAddBleTempPwd,
     removeTempPwd,
     reportRemoveTempPwd,
     updateTempPwd,
+    updateBleTempPwd,
     reportUpdateTempPwd,
     sync,
     reportSync,

package/lib/constant.d.ts

@@ -71,3 +71,8 @@ export declare enum LocalOperateCategory {
     DELETE_USER = 17,
     SETTING = 32
 }
+export declare enum RemotePermissionType {
+    EVERY_ONE = "everyOne",
+    ADMINS_ONLY = "adminsOnly",
+    NO_ONE = "noOne"
+}

package/lib/constant.js

@@ -81,3 +81,9 @@ export var LocalOperateCategory;
     LocalOperateCategory[LocalOperateCategory["DELETE_USER"] = 17] = "DELETE_USER";
     LocalOperateCategory[LocalOperateCategory["SETTING"] = 32] = "SETTING";
 })(LocalOperateCategory || (LocalOperateCategory = {}));
+export var RemotePermissionType;
+(function (RemotePermissionType) {
+    RemotePermissionType["EVERY_ONE"] = "everyOne";
+    RemotePermissionType["ADMINS_ONLY"] = "adminsOnly";
+    RemotePermissionType["NO_ONE"] = "noOne";
+})(RemotePermissionType || (RemotePermissionType = {}));

package/lib/entries/ble/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 "../build-instance";
+export declare function bootstrapRegisteredLockInstance(options?: LockSDKOption): Promise<{
+    runtime: LockDeviceRuntime;
+    instance: LockSDKInstance;
+}>;

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

@@ -0,0 +1,12 @@
+import { addEvents } from "../../../feature/state/platform-routing";
+import { initState } from "../../../feature/state/init-state";
+import { registerRuntime } from "../../../runtime/registry";
+import { buildLockSDKInstance, } from "../build-instance";
+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) };
+}

package/lib/entries/ble/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/entries/ble/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/entries/ble/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/entries/ble/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/entries/ble/bootstrap/primary-instance.d.ts

@@ -0,0 +1,6 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { LockSDKInstance } from "../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/entries/ble/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/entries/ble/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/entries/ble/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/entries/ble/bootstrap/top-level-runtime.d.ts

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

package/lib/entries/ble/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;
+}

package/lib/entries/ble/build-instance.d.ts

@@ -0,0 +1,9 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { type UpdateConfigParams } from "../../feature/misc/update-config";
+import * as DeviceExports from "./exports";
+export type LockSDKInstance = {
+    destroy(): void;
+    updateConfig(options: UpdateConfigParams): void;
+} & Omit<typeof DeviceExports, "updateConfig">;
+export declare function getFlatInstanceMethodKeysForTests(): string[];
+export declare function buildLockSDKInstance(runtime: LockDeviceRuntime): LockSDKInstance;