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

package/lib/entries/main/exports/temporary.js

@@ -0,0 +1,86 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { createTempCustomForRuntime, removeTempCustomForRuntime, updateTempCustomForRuntime, } from "../../../feature/password/temporary/custom-dp";
+import { createTempCustomForRuntime as createTempCustomForRuntimeBle, updateTempCustomForRuntime as updateTempCustomForRuntimeBle, removeTempCustomForRuntime as removeTempCustomForRuntimeBle, } from "../../../feature/password/temporary/custom-dp-ble";
+import { createTempClearForRuntime, createTempDynamicForRuntime, createTempLimitForRuntime, createTempOnceForRuntime, } from "../../../feature/password/temporary/offline-create";
+import { clearTempInvalidListForRuntime, getTempEffectiveListForRuntime, getTempInvalidListForRuntime, getTempLimitListForClearForRuntime, } from "../../../feature/password/temporary/lists";
+import { freezeTempForRuntime, renameTempForRuntime, unfreezeTempForRuntime, } from "../../../feature/password/temporary/freeze-rename";
+import { getTempOnlineUnlimitedListForRuntime, removeTempOnlineUnlimitedForRuntime, saveTempOnlineUnlimitedForRuntime, } from "../../../feature/password/temporary/wifi-online";
+import { createTempOfflineForRuntime, getTempOfflineEffectiveListForRuntime, getTempOfflineInvalidListForRuntime, } from "../../../feature/password/temporary/wifi-offline";
+import { isBlePureDeviceForRuntime } from "../../../feature/misc/capability";
+export function createTempCustom(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    const isBlePureDevice = isBlePureDeviceForRuntime(rt);
+    if (isBlePureDevice) {
+        return createTempCustomForRuntimeBle(rt, params);
+    }
+    return createTempCustomForRuntime(rt, params);
+}
+export function removeTempCustom(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    const isBlePureDevice = isBlePureDeviceForRuntime(rt);
+    if (isBlePureDevice) {
+        return removeTempCustomForRuntimeBle(rt, params);
+    }
+    return removeTempCustomForRuntime(rt, params);
+}
+export function updateTempCustom(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    const isBlePureDevice = isBlePureDeviceForRuntime(rt);
+    if (isBlePureDevice) {
+        return updateTempCustomForRuntimeBle(rt, params);
+    }
+    return updateTempCustomForRuntime(rt, params);
+}
+export function getTempEffectiveList() {
+    return getTempEffectiveListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getTempInvalidList(params) {
+    return getTempInvalidListForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function clearTempInvalidList() {
+    return clearTempInvalidListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function freezeTemp(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    return freezeTempForRuntime(rt, params);
+}
+export function unfreezeTemp(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    return unfreezeTempForRuntime(rt, params);
+}
+export function renameTemp(params) {
+    return renameTempForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function saveTempOnlineUnlimited(params) {
+    return saveTempOnlineUnlimitedForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function removeTempOnlineUnlimited(id) {
+    return removeTempOnlineUnlimitedForRuntime(resolveRuntimeFromExportThis(this), id);
+}
+export function getTempOnlineUnlimitedList() {
+    return getTempOnlineUnlimitedListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function createTempOffline(params) {
+    return createTempOfflineForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getTempOfflineEffectiveList(pwdTypeCode) {
+    return getTempOfflineEffectiveListForRuntime(resolveRuntimeFromExportThis(this), pwdTypeCode);
+}
+export function getTempOfflineInvalidList(pwdTypeCode) {
+    return getTempOfflineInvalidListForRuntime(resolveRuntimeFromExportThis(this), pwdTypeCode);
+}
+export function createTempLimit(params) {
+    return createTempLimitForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function createTempOnce(params) {
+    return createTempOnceForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function createTempDynamic() {
+    return createTempDynamicForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function createTempClear(params) {
+    return createTempClearForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getTempLimitListForClear() {
+    return getTempLimitListForClearForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/unlock/sync.d.ts

@@ -0,0 +1 @@
+export declare function syncUnlockMethod(): Promise<void>;

package/lib/entries/main/exports/unlock/sync.js

@@ -0,0 +1,5 @@
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+import { syncUnlockMethodWithRuntime } from "../../../../feature/unlock/sync/unlock-method";
+export async function syncUnlockMethod() {
+    return syncUnlockMethodWithRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/unlock-method.d.ts

@@ -0,0 +1,19 @@
+import type { AddPasswordParams, AddUnlockMethodBaseParams, AddUnlockMethodEvent, AddUnlockMethodListener, BindUnlockMethodFromLogParams, BindUnlockMethodParams, CancelAddUnlockMethodParams, SendVerifyCodeParams, SpecialUnlockMethodInfo, StartAddUnlockMethodParams, updateUnlockMethodParams } from "../../../feature/unlock/method/types";
+import type { UnlockMethodType } from "../../../interface";
+export type { AddPasswordParams, AddUnlockMethodBaseParams, AddUnlockMethodEvent, AddUnlockMethodListener, SpecialUnlockMethodInfo, updateUnlockMethodParams, };
+export declare function getUnlockMethodDetail(id: number): Promise<import("../../../interface").UnlockMethodDetail>;
+export declare function checkSpecialSupportPhone(): boolean;
+export declare function addPassword(params: AddPasswordParams): Promise<import("../../../api/lock").CreateUnlockMethodResult>;
+export declare function startAddUnlockMethod(params: StartAddUnlockMethodParams): Promise<import("../../../feature/unlock/method/add-flow").StartAddUnlockMethodResult>;
+export declare function cancelAddUnlockMethod(params: CancelAddUnlockMethodParams): Promise<void>;
+export declare function updateUnlockMethod(params: updateUnlockMethodParams): Promise<void>;
+export declare function deleteUnlockMethod(id: number): Promise<void>;
+export declare function checkUnBindUnlockMethods(): Promise<boolean>;
+export declare function getUnbindUnlockMethods(): Promise<import("../../../interface").UnBindUnlockMethodGroup[]>;
+export declare function bindUnlockMethod(params: BindUnlockMethodParams): Promise<boolean>;
+export declare function unbindUnlockMethod(id: number): Promise<void>;
+export declare function bindUnlockMethodFromLog(params: BindUnlockMethodFromLogParams): Promise<boolean>;
+export declare function sendVerifyCode(params: SendVerifyCodeParams): Promise<void>;
+export declare function onAddUnlockMethod(listener: AddUnlockMethodListener): void;
+export declare function offAddUnlockMethod(listener: AddUnlockMethodListener): void;
+export declare function getUnlockGuide(type: UnlockMethodType): Promise<import("../../../interface").UnlockGuide | null>;

package/lib/entries/main/exports/unlock-method.js

@@ -0,0 +1,58 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { addPasswordForRuntime } from "../../../feature/unlock/method/add-password";
+import { cancelAddUnlockMethodForRuntime, startAddUnlockMethodForRuntime, } from "../../../feature/unlock/method/add-flow";
+import { deleteUnlockMethodForRuntime, updateUnlockMethodForRuntime, } from "../../../feature/unlock/method/update-remove";
+import { bindUnlockMethodForRuntime, bindUnlockMethodFromLogForRuntime, checkUnBindUnlockMethodsForRuntime, getUnbindUnlockMethodsForRuntime, unbindUnlockMethodForRuntime, } from "../../../feature/unlock/method/bind-unbind";
+import { getUnlockMethodDetailForRuntime } from "../../../feature/unlock/method/detail";
+import { getUnlockGuideForRuntime } from "../../../feature/unlock/method/guide";
+import { checkSpecialSupportPhoneForRuntime } from "../../../feature/unlock/method/internal/special-check";
+import { sendVerifyCodeForRuntime } from "../../../feature/unlock/method/verify-code";
+import { onAddUnlockMethodForRuntime, offAddUnlockMethodForRuntime, } from "../../../feature/unlock/method/add-method-events";
+export function getUnlockMethodDetail(id) {
+    return getUnlockMethodDetailForRuntime(resolveRuntimeFromExportThis(this), id);
+}
+export function checkSpecialSupportPhone() {
+    return checkSpecialSupportPhoneForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function addPassword(params) {
+    return addPasswordForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function startAddUnlockMethod(params) {
+    return startAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function cancelAddUnlockMethod(params) {
+    return cancelAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function updateUnlockMethod(params) {
+    return updateUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function deleteUnlockMethod(id) {
+    return deleteUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), id);
+}
+export function checkUnBindUnlockMethods() {
+    return checkUnBindUnlockMethodsForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getUnbindUnlockMethods() {
+    return getUnbindUnlockMethodsForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function bindUnlockMethod(params) {
+    return bindUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function unbindUnlockMethod(id) {
+    return unbindUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), id);
+}
+export function bindUnlockMethodFromLog(params) {
+    return bindUnlockMethodFromLogForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function sendVerifyCode(params) {
+    return sendVerifyCodeForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function onAddUnlockMethod(listener) {
+    onAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function offAddUnlockMethod(listener) {
+    offAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function getUnlockGuide(type) {
+    return getUnlockGuideForRuntime(resolveRuntimeFromExportThis(this), type);
+}

package/lib/entries/main/exports/user/index.d.ts

@@ -0,0 +1,33 @@
+import type { EffectiveConfig } from "../../../../interface";
+import { type AddSharedUserParams, type RemoveSharedUserParams, type UpdateSharedUserParams } from "../../../../feature/user/share-user";
+export { openAddFamilyUser } from "../../../../feature/user/user";
+export * from "./sync";
+interface GetUsersParams {
+    page?: number;
+    pageSize?: number;
+    keyword?: string;
+}
+export declare function getUsers(params?: GetUsersParams): Promise<import("../../../../feature/user/user").getUsersResult>;
+interface GetUserInfoParams {
+    userId: string;
+}
+export declare function getUserInfo(params: GetUserInfoParams): Promise<import("../../../../interface").UserInfo>;
+interface UpdateUserLimitTimeParams {
+    userId: string;
+    lockUserId: number;
+    permanent: boolean;
+    effective?: EffectiveConfig;
+    offlineUnlock?: boolean;
+}
+export declare function updateUserLimitTime(params: UpdateUserLimitTimeParams): Promise<void>;
+export declare function openFamilyUserDetail(userId: string): Promise<void>;
+interface AddUserParams {
+    name: string;
+}
+export declare function addUser(params: AddUserParams): Promise<void>;
+export declare function removeUser(userId: string): Promise<void>;
+export declare function addSharedUser(params: AddSharedUserParams): Promise<import("../../../../feature/user/share-user").AddSharedUserResult>;
+export declare function updateSharedUser(params: UpdateSharedUserParams): Promise<void>;
+export declare function removeSharedUser(params: RemoveSharedUserParams): Promise<void>;
+export declare function getSharedUserList(): Promise<import("../../../../interface").SharedUserInfo[]>;
+export type { AddSharedUserParams, RemoveSharedUserParams, UpdateSharedUserParams, };

package/lib/entries/main/exports/user/index.js

@@ -0,0 +1,35 @@
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+import { addSharedUserForRuntime, getSharedUserListForRunTime, removeSharedUserForRuntime, updateSharedUserForRuntime, } from "../../../../feature/user/share-user";
+import { getUsersForRuntime, getUserInfoForRuntime, updateUserLimitTimeForRuntime, openFamilyUserDetailForRuntime, addUserForRuntime, removeUserForRuntime, } from "../../../../feature/user/user";
+export { openAddFamilyUser } from "../../../../feature/user/user";
+export * from "./sync";
+export async function getUsers(params) {
+    return getUsersForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function getUserInfo(params) {
+    return getUserInfoForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function updateUserLimitTime(params) {
+    return updateUserLimitTimeForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function openFamilyUserDetail(userId) {
+    return openFamilyUserDetailForRuntime(resolveRuntimeFromExportThis(this), userId);
+}
+export async function addUser(params) {
+    return addUserForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function removeUser(userId) {
+    return removeUserForRuntime(resolveRuntimeFromExportThis(this), userId);
+}
+export async function addSharedUser(params) {
+    return addSharedUserForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function updateSharedUser(params) {
+    return updateSharedUserForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function removeSharedUser(params) {
+    return removeSharedUserForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function getSharedUserList() {
+    return getSharedUserListForRunTime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/user/sync.d.ts

@@ -0,0 +1 @@
+export declare function syncDeleteUsers(): Promise<void>;

package/lib/entries/main/exports/user/sync.js

@@ -0,0 +1,5 @@
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+import { syncDeleteUsersWithRuntime } from "../../../../feature/user/sync-user";
+export async function syncDeleteUsers() {
+    return syncDeleteUsersWithRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/voice-file.d.ts

@@ -0,0 +1,7 @@
+import { type VoiceFileProgressCallback, type VoiceFileItem } from "../../../feature/voice-file/voice-file";
+export type { VoiceFileItem, VoiceFileProgressCallback, VoiceFileProgressEvent, VoiceFileStatus, } from "../../../feature/voice-file/voice-file";
+export declare function getVoiceFileList(): Promise<VoiceFileItem[]>;
+export declare function sendVoiceFile(file: VoiceFileItem): Promise<true>;
+export declare function onVoiceFileProgress(callback: VoiceFileProgressCallback): void;
+export declare function offVoiceFileProgress(callback: VoiceFileProgressCallback): void;
+export declare function getCurrentVoiceFile(): import("../../../feature/voice-file/voice-file").VoiceFileStatus | null;

package/lib/entries/main/exports/voice-file.js

@@ -0,0 +1,17 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getCurrentVoiceFileForRuntime, getVoiceFileListForRuntime, offVoiceFileProgressForRuntime, onVoiceFileProgressForRuntime, sendVoiceFileForRuntime, } from "../../../feature/voice-file/voice-file";
+export async function getVoiceFileList() {
+    return getVoiceFileListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function sendVoiceFile(file) {
+    return sendVoiceFileForRuntime(resolveRuntimeFromExportThis(this), file);
+}
+export function onVoiceFileProgress(callback) {
+    return onVoiceFileProgressForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function offVoiceFileProgress(callback) {
+    return offVoiceFileProgressForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function getCurrentVoiceFile() {
+    return getCurrentVoiceFileForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/voip.d.ts

@@ -0,0 +1,3 @@
+export type { VoipAuth } from "../../../api/voip";
+export declare function getVoipAuth(): Promise<import("../../../api/voip").VoipAuth>;
+export declare function saveVoipAuth(userId: string): Promise<boolean>;

package/lib/entries/main/exports/voip.js

@@ -0,0 +1,8 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getVoipAuthForRuntime, saveVoipAuthForRuntime, } from "../../../feature/voip/voip";
+export async function getVoipAuth() {
+    return getVoipAuthForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function saveVoipAuth(userId) {
+    return saveVoipAuthForRuntime(resolveRuntimeFromExportThis(this), userId);
+}

package/lib/entries/main/exports/yu-channel.d.ts

@@ -0,0 +1,5 @@
+export declare const isSupportYuChannel: () => 0 | 1 | 2;
+export declare const isYuChannelOnline: () => boolean;
+export declare const updateYuChannelState: (enabled: boolean) => Promise<void>;
+export declare const getYuChannelNodes: () => Promise<string[]>;
+export declare const getYuChannelState: () => boolean;

package/lib/entries/main/exports/yu-channel.js

@@ -0,0 +1,17 @@
+import { getYuChannelNodesForRuntime, getYuChannelStateForRuntime, isSupportYuChannelForRuntime, isYuChannelOnlineForRuntime, updateYuChannelStateForRuntime, } from "../../../feature/misc/yu-channel";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export const isSupportYuChannel = () => {
+    return isSupportYuChannelForRuntime(resolveRuntimeFromExportThis(this));
+};
+export const isYuChannelOnline = () => {
+    return isYuChannelOnlineForRuntime(resolveRuntimeFromExportThis(this));
+};
+export const updateYuChannelState = (enabled) => {
+    return updateYuChannelStateForRuntime(resolveRuntimeFromExportThis(this), enabled);
+};
+export const getYuChannelNodes = () => {
+    return getYuChannelNodesForRuntime(resolveRuntimeFromExportThis(this));
+};
+export const getYuChannelState = () => {
+    return getYuChannelStateForRuntime(resolveRuntimeFromExportThis(this));
+};

package/lib/entries/main/index.d.ts

@@ -0,0 +1,8 @@
+import type { LockSDKOption } from "../../interface";
+import type { LockSDKInstance } from "./build-instance";
+export * from "./exports";
+export type { LockSDKInstance };
+export type { LockSdkBoundExportThis } from "./bootstrap/resolve-runtime-from-export-this";
+export declare const createLockSDK: (options?: Omit<LockSDKOption, "preFetch">) => Promise<LockSDKInstance>;
+export declare const init: (options?: LockSDKOption) => Promise<void>;
+export declare const destroy: () => void;

package/lib/entries/main/index.js

@@ -0,0 +1,36 @@
+import { clearStateForRuntime } from "../../feature/state/clear";
+import { removeEvents } from "../../feature/state/platform-routing";
+import { bootstrapRegisteredLockInstance } from "./bootstrap/bootstrap-lock-instance";
+import { clearPrimaryLockSDKInstance, setPrimaryLockSDKInstance, } from "./bootstrap/primary-instance";
+import { clearAllRuntimes, listRegisteredRuntimes, } from "../../runtime/registry";
+import { getLaunchOptionsSync } from "../../platform/device";
+import { getError } from "../../utils/errors";
+export * from "./exports";
+export const createLockSDK = async (options) => {
+    const { instance } = await bootstrapRegisteredLockInstance({
+        ...options,
+        preFetch: false,
+    });
+    return instance;
+};
+export const init = async (options) => {
+    const opts = { ...options };
+    const { devInfo, deviceId } = opts;
+    if (!devInfo && !deviceId) {
+        const { query } = getLaunchOptionsSync();
+        opts.deviceId = query.deviceId;
+        if (!opts.deviceId) {
+            throw getError(1000);
+        }
+    }
+    const { instance } = await bootstrapRegisteredLockInstance(opts);
+    setPrimaryLockSDKInstance(instance);
+};
+export const destroy = () => {
+    removeEvents();
+    for (const rt of listRegisteredRuntimes()) {
+        clearStateForRuntime(rt);
+    }
+    clearAllRuntimes();
+    clearPrimaryLockSDKInstance();
+};

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

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

package/lib/entries/screen/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 { buildScreenSDKInstance } from "../build-instance";
+import { createBootstrappedRuntime } from "./bootstrap";
+export async function bootstrapRegisteredScreenInstance(options) {
+    const runtime = await createBootstrappedRuntime(options);
+    registerRuntime(runtime);
+    addEvents(runtime);
+    await initState(runtime);
+    return { runtime, instance: buildScreenSDKInstance(runtime) };
+}

package/lib/entries/screen/bootstrap/bootstrap.d.ts

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

package/lib/entries/screen/bootstrap/bootstrap.js

@@ -0,0 +1,69 @@
+import dpCodes from "../../../config/dp-code";
+import { getCapabilities } from "../../../utils";
+import { getDeviceInfo, trackEvent } from "../../../platform/device";
+import { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import { sdkLog, setSDKLogConfig } from "../../../utils/sdk-log";
+export async function applyScreenOptionsToRuntime(runtime, options) {
+    setSDKLogConfig({
+        level: options?.logLevel ?? "warn",
+        sink: options?.logger,
+        console: options?.logToConsole ?? false,
+    });
+    const { config } = runtime;
+    let { devInfo, deviceId } = options || {};
+    if (!devInfo && !deviceId) {
+        throw new Error("deviceId is required in screen 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);
+    sdkLog("info", "screen-bootstrap", "applyOptions", {
+        devId: config.devInfo.devId,
+        data: {
+            productId: config.devInfo.productId,
+            strictMode: config.strictMode,
+            supportOfflineDps: config.supportOfflineDps,
+            supportBigData: config.supportBigData,
+            communication: config.communication,
+        },
+    });
+    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
+        pid: devInfo.productId,
+    });
+}
+export async function createBootstrappedRuntime(options) {
+    const runtime = new LockDeviceRuntime();
+    await applyScreenOptionsToRuntime(runtime, options);
+    return runtime;
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { ScreenSDKInstance } from "../build-instance";
+export declare function setPrimaryScreenSDKInstance(instance: ScreenSDKInstance): void;
+export declare function getPrimaryScreenSDKRuntime(): LockDeviceRuntime | null;
+export declare function clearPrimaryScreenSDKInstance(): void;
+export declare function clearPrimaryScreenSDKInstanceIfDevId(devId: string): void;

package/lib/entries/screen/bootstrap/primary-instance.js

@@ -0,0 +1,24 @@
+import { getRuntimeForScreenSDKInstance } from "./lock-instance-runtime-ref";
+let primaryDevId = null;
+let primaryRuntime = null;
+export function setPrimaryScreenSDKInstance(instance) {
+    const runtime = getRuntimeForScreenSDKInstance(instance);
+    if (!runtime) {
+        throw new Error("setPrimaryScreenSDKInstance: instance must be returned by createScreenSDK or initScreen");
+    }
+    primaryDevId = runtime.devId;
+    primaryRuntime = runtime;
+}
+export function getPrimaryScreenSDKRuntime() {
+    return primaryRuntime;
+}
+export function clearPrimaryScreenSDKInstance() {
+    primaryDevId = null;
+    primaryRuntime = null;
+}
+export function clearPrimaryScreenSDKInstanceIfDevId(devId) {
+    if (primaryDevId === devId) {
+        primaryDevId = null;
+        primaryRuntime = null;
+    }
+}

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

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

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

@@ -0,0 +1,29 @@
+import { getRuntimeByDevId } from "../../../runtime/registry";
+import { getRuntimeForScreenSDKInstance } 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 = getRuntimeForScreenSDKInstance(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("Screen SDK: bound context devId must be non-empty");
+        }
+        const rt = getRuntimeByDevId(devId);
+        if (!rt) {
+            throw new Error(`Screen SDK: no registered runtime for devId "${devId}"; use createScreenSDK or initScreen first`);
+        }
+        return rt;
+    }
+    return resolveTopLevelTargetRuntime();
+}

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

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

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

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

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

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

package/lib/entries/screen/build-instance.js

@@ -0,0 +1,57 @@
+import { clearPrimaryScreenSDKInstanceIfDevId } from "./bootstrap/primary-instance";
+import { registerScreenSDKInstanceRuntime } from "./bootstrap/lock-instance-runtime-ref";
+import { getRegisteredRuntimeCount, unregisterRuntime, } from "../../runtime/registry";
+import { clearStateForRuntime } from "../../feature/state/clear";
+import { removeEvents } from "../../feature/state/platform-routing";
+import { updateConfigForRuntime, } from "../../feature/misc/update-config";
+import { sdkLog } from "../../utils/sdk-log";
+import * as ScreenExports from "./exports";
+const RESERVED_INSTANCE_METHOD_KEYS = new Set(["destroy", "updateConfig"]);
+let cachedFlatExportKeys = null;
+function collectFlatInstanceExportKeys() {
+    if (cachedFlatExportKeys !== null) {
+        return cachedFlatExportKeys;
+    }
+    const ex = ScreenExports;
+    cachedFlatExportKeys = Object.keys(ex)
+        .filter((k) => k !== "__esModule" && !RESERVED_INSTANCE_METHOD_KEYS.has(k))
+        .sort();
+    return cachedFlatExportKeys;
+}
+export function getFlatScreenInstanceMethodKeysForTests() {
+    return collectFlatInstanceExportKeys();
+}
+export function buildScreenSDKInstance(runtime) {
+    const instance = {
+        destroy() {
+            sdkLog("info", "screen-lifecycle", "destroy", { devId: runtime.devId });
+            unregisterRuntime(runtime.devId);
+            clearPrimaryScreenSDKInstanceIfDevId(runtime.devId);
+            clearStateForRuntime(runtime);
+            if (getRegisteredRuntimeCount() === 0) {
+                removeEvents();
+            }
+        },
+        updateConfig(options) {
+            sdkLog("info", "screen-lifecycle", "updateConfig", {
+                devId: runtime.devId,
+                data: { keys: Object.keys(options) },
+            });
+            updateConfigForRuntime(runtime, options);
+        },
+    };
+    registerScreenSDKInstanceRuntime(instance, runtime);
+    sdkLog("info", "screen-lifecycle", "createInstance", { devId: runtime.devId });
+    const keys = collectFlatInstanceExportKeys();
+    const ex = ScreenExports;
+    for (const key of keys) {
+        const val = ex[key];
+        if (typeof val === "function") {
+            instance[key] = val.bind(instance);
+        }
+        else {
+            instance[key] = val;
+        }
+    }
+    return instance;
+}