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

package/lib/utils/errors.js

@@ -1,8 +1,9 @@
 const errors = {
+    1000: "Missing DeviceId or devInfo",
     1001: "Device offline",
     1002: "Operation timeout",
     1003: "Remote unlocking failure",
-    1004: "Device reports that remote unlocking failed",
+    1004: "Device reports that unlocking failed",
     1005: "Remote unlocking failure",
     1006: "Secret key times has been used up",
     1007: "Secret key is not valid",
@@ -29,16 +30,16 @@ const errors = {
     1028: "Delete failed",
     1029: "Hardware ID cannot be deleted",
     1030: "Only numeric passwords are supported",
-    1031: "Password name length cannot exceed 20 characters",
+    1031: "name length cannot exceed 20 characters",
     1032: "Validity not configured",
     1033: "Validity start date not configured",
     1034: "Validity end date not configured",
     1035: "Weekly repeat validity configuration not set",
     1036: "Monthly repeat validity configuration not set",
     1037: "Password already exists",
-    1038: "Password name is duplicated",
+    1038: "name is duplicated",
     1039: "Password effective time and end time are incorrect",
-    1040: "Temporary password ID does not exist",
+    1040: "Record does not exist",
     1041: "Device has no hardware ID available",
     1042: "Failed to add temporary password",
     1043: "Temporary password addition failed, pre-allocated number not obtained from cloud",
@@ -68,6 +69,40 @@ const errors = {
     1067: "Password limit reached within this period",
     1068: "There is already a member with the same name",
     1069: "No permission to modify member validity",
+    1070: "Lock SDK runtime already registered for device {0}",
+    1071: "SDK instance not set, please call init",
+    1072: "Does not support deleting family members",
+    1073: "User has been frozen",
+    1074: "User has expired",
+    1075: "User has not taken effect",
+    1076: "Share user or normal member has no permission to open/close the door",
+    1077: "Bluetooth unlocking, host ID error",
+    1078: "Bluetooth unlocking, slave ID error",
+    1079: "Bluetooth unlocking, random number error",
+    1080: "Bluetooth unlocking, parameter error",
+    1081: "Bluetooth unlocking, electronic anti-lock refuses to unlock",
+    1082: "Failed to modify temporary password",
+    1083: "Does not support emojis",
+    1084: "Incorrect sharing account",
+    1085: "Virtual key is not available",
+    1086: "Device does not exist",
+    1087: "Bluetooth sharing name already exists",
+    1088: "Fitting not bound to a lock",
+    1089: "Lock not found",
+    1090: "Update failed",
+    1091: "Parameter error",
+    1092: "No record on the device",
+    1093: "Non-admin has no permission to operate",
+    1094: "Illegal user request",
+    1095: "Lock not found",
+    1096: "Accessory and lock are not in the same home",
+    1097: "Target lock is not online",
+    1098: "Target lock does not support accessory binding",
+    1099: "Accessory does not support binding to a lock",
+    1100: "Binding limit reached",
+    1101: "The lock has already been bound, please do not bind it again",
+    1102: "Lock is binding",
+    1103: "Binding failed"
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {

package/lib/utils/event.js

@@ -1,3 +1,4 @@
+import { sdkLog } from "./sdk-log";
 function createEmitter() {
     let listeners = {};
     let cachedEvents = {};
@@ -65,7 +66,7 @@ function createEmitter() {
                     cb(data);
                 }
                 catch (e) {
-                    console.warn(e);
+                    sdkLog("warn", "event", "listenerError", { error: e });
                 }
             }
         }

package/lib/utils/index.d.ts

@@ -1,5 +1,5 @@
 import { UserType } from "../constant";
-import { EffectiveConfig, UnlockMethodConfig, Week } from "../interface";
+import type { EffectiveConfig, Week } from "../interface";
 import { LoopTypes } from "./constant";
 export declare const get24Time: (time: number) => number[];
 export declare const getNowTime: () => number;
@@ -102,18 +102,9 @@ export declare const getPermanentSetting: () => {
 };
 export declare const isAdmin: (userType: UserType) => boolean;
 export declare const validateEffectiveConfig: (effective?: EffectiveConfig) => void;
-export declare const isUseNearChannel: () => boolean;
-export declare const parseOfflinePassword: (value: string) => string;
 export declare const formatTimestampToMilliseconds: (timestamp: number) => number;
-export declare const unlockMethodConfigs: UnlockMethodConfig[];
-export declare const getUnlockMethodTypeByDpCode: (dpCode: string) => UnlockMethodConfig;
-export declare const getUnlockMethodTypeById: (id: number | string) => UnlockMethodConfig;
-export declare const getUnlockMethodTypeByType: (type: string) => UnlockMethodConfig;
-export declare const parallelMerge: <T extends (...args: any[]) => Promise<any>>(cb: T) => (...args: Parameters<T>) => ReturnType<T>;
-export declare const parallelOnly: <T extends (...args: any[]) => Promise<any>>(cb: T) => (...args: Parameters<T>) => ReturnType<T>;
-declare const preFetchKeys: readonly ["getRotate", "getCurrentUser", "getDeviceProperties"];
-type PreFetchKey = (typeof preFetchKeys)[number];
-export declare const getDataWithPreFetch: <T>(key: PreFetchKey, apiCb: () => Promise<T>) => Promise<T>;
+export declare const parallelMerge: <T extends (...args: any[]) => Promise<any>>(cb: T) => (this: unknown, ...args: Parameters<T>) => Promise<any>;
+export declare const parallelOnly: <T extends (...args: any[]) => Promise<any>>(cb: T) => (this: unknown, ...args: Parameters<T>) => Promise<any>;
 export declare const equels: (source: any, target: any) => boolean;
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare const getHomeInfo: () => Promise<{
@@ -124,4 +115,22 @@ export declare const getHomeInfo: () => Promise<{
     address: string;
     admin: boolean;
 }>;
-export {};
+export declare const transformEffectiveConfigToValidConfig: (effective: EffectiveConfig) => {
+    startTime: number;
+    endTime: number;
+    loop: LoopTypes;
+    loopConfig: number;
+    weeks: number[];
+    days: never[];
+    startHour: number;
+    startMinute: number;
+    endHour: number;
+    endMinute: number;
+};
+export declare const formatPasswordToList: (password: string) => number[];
+export declare const getAppUser: () => {
+    nickName: string;
+    avatarUrl: string;
+    phoneCode: string;
+    isTemporaryUser: boolean;
+} | null;

package/lib/utils/index.js

@@ -1,8 +1,5 @@
-import config, { hasCapability } from "../config";
-import dpCodes from "../config/dp-code";
-import { ProductCommunicationType } from "../constant";
 import { LoopTypes } from "./constant";
-import { getBackgroundFetchData, getCurrentHomeInfo, onBackgroundFetchData, } from "./device";
+import { getAppUserInfo, getCurrentHomeInfo } from "../platform/device";
 import { getError } from "./errors";
 export const get24Time = (time) => {
     const hours = Math.floor(time / 60);
@@ -97,97 +94,16 @@ export const validateEffectiveConfig = (effective) => {
             break;
     }
 };
-export const isUseNearChannel = () => {
-    const { onlineType, devInfo } = config;
-    const isBleOnline = isOnlineByType(onlineType, 2);
-    const isSupportWifi = hasCapability(ProductCommunicationType.WIFI);
-    const isSupportBle = hasCapability(ProductCommunicationType.BLUETOOTH);
-    const isSupportThread = hasCapability(ProductCommunicationType.THREAD);
-    if (isSupportWifi && isSupportBle) {
-        return isBleOnline;
-    }
-    if (isSupportThread && isSupportBle) {
-        return isBleOnline && !devInfo.isCloudOnline && !devInfo.isLocalOnline;
-    }
-    return isBleOnline;
-};
-export const parseOfflinePassword = (value) => {
-    if (config.passwordDigitalBase === 10) {
-        return value;
-    }
-    let digitalCode = Number(value).toString(config.passwordDigitalBase);
-    const zeroList = value.match(/(^0+)/);
-    if (zeroList) {
-        digitalCode = zeroList[0] + digitalCode;
-    }
-    if (config.passwordSupportZero === false) {
-        digitalCode = digitalCode
-            .split("")
-            .map((n) => {
-            return Number(n) + 1;
-        })
-            .join("");
-    }
-    return digitalCode;
-};
 export const formatTimestampToMilliseconds = (timestamp) => {
     const isMilliseconds = timestamp.toString().length >= 13;
     return isMilliseconds ? timestamp : timestamp * 1000;
 };
-export const unlockMethodConfigs = [
-    {
-        type: "password",
-        code: dpCodes.unlockPassword,
-        id: 1,
-    },
-    {
-        type: "card",
-        code: dpCodes.unlockCard,
-        id: 2,
-    },
-    {
-        type: "finger",
-        code: dpCodes.unlockFingerprint,
-        id: 3,
-    },
-    {
-        type: "face",
-        code: dpCodes.unlockFace,
-        id: 4,
-    },
-    {
-        type: "hand",
-        code: dpCodes.unlockHand,
-        id: 5,
-    },
-    {
-        type: "fingerVein",
-        code: dpCodes.unlockFingerVein,
-        id: 6,
-    },
-];
-const getUnlockMethodType = (cb) => {
-    const result = unlockMethodConfigs.find(cb);
-    if (result && config.dpSchema[result.code]) {
-        return result;
-    }
-    throw getError(1014);
-};
-export const getUnlockMethodTypeByDpCode = (dpCode) => {
-    return getUnlockMethodType((item) => item.code === dpCode);
-};
-export const getUnlockMethodTypeById = (id) => {
-    return getUnlockMethodType((item) => item.id === id);
-};
-export const getUnlockMethodTypeByType = (type) => {
-    return getUnlockMethodType((item) => item.type === type);
-};
 let cbIndex = 0;
 const cbMap = {};
 export const parallelMerge = (cb) => {
     let isRuning = false;
     let cbId = cbIndex++;
-    return async (...args) => {
+    return async function (...args) {
         const key = JSON.stringify(args);
         if (isRuning) {
             if (!cbMap[cbId]) {
@@ -202,7 +118,7 @@ export const parallelMerge = (cb) => {
         }
         isRuning = true;
         try {
-            const result = await cb(...args);
+            const result = await cb.apply(this, args);
             isRuning = false;
             if (cbMap[cbId] && cbMap[cbId][key]) {
                 let list = cbMap[cbId][key];
@@ -229,14 +145,14 @@ export const parallelMerge = (cb) => {
 export const parallelOnly = (cb) => {
     let isRuning = false;
     let cbId = cbIndex++;
-    return async (...args) => {
+    return async function (...args) {
         let key;
         if (isRuning) {
             throw getError(1052);
         }
         isRuning = true;
         try {
-            const result = await cb(...args);
+            const result = await cb.apply(this, args);
             isRuning = false;
             return result;
         }
@@ -246,35 +162,6 @@ export const parallelOnly = (cb) => {
         }
     };
 };
-const preFetchKeys = [
-    "getRotate",
-    "getCurrentUser",
-    "getDeviceProperties",
-];
-const preFetchData = {};
-onBackgroundFetchData(preFetchKeys, (res) => {
-    Object.keys(res?.fetchedData ?? {}).forEach((key) => {
-        preFetchData[key] = res.fetchedData[key].fetchedData;
-    });
-});
-export const getDataWithPreFetch = async (key, apiCb) => {
-    if (config.preFetch) {
-        if (preFetchData[key]) {
-            return preFetchData[key];
-        }
-        try {
-            const result = await getBackgroundFetchData([key]);
-            if (result &&
-                result.fetchedData[key] &&
-                result.fetchedData[key].fetchedData) {
-                return result.fetchedData[key].fetchedData;
-            }
-        }
-        catch {
-        }
-    }
-    return apiCb();
-};
 export const equels = (source, target) => {
     return JSON.stringify(source) === JSON.stringify(target);
 };
@@ -289,3 +176,37 @@ export const getHomeInfo = async () => {
     homeInfo = await getCurrentHomeInfo();
     return homeInfo;
 };
+export const transformEffectiveConfigToValidConfig = (effective) => {
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    return {
+        startTime: effective.effectiveDate,
+        endTime: effective.expiredDate,
+        loop: loopType,
+        loopConfig: 0,
+        weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
+        days: [],
+        startHour: Math.floor(effectiveTime / 60),
+        startMinute: effectiveTime % 60,
+        endHour: Math.floor(expiredTime / 60),
+        endMinute: expiredTime % 60,
+    };
+};
+export const formatPasswordToList = (password) => {
+    return password.split("").map(Number);
+};
+let userInfo = null;
+export const getAppUser = () => {
+    return userInfo;
+};
+const getAppUserAsync = async () => {
+    const res = await getAppUserInfo();
+    userInfo = res;
+    return res;
+};
+getAppUserAsync().catch(() => {
+    getAppUserAsync().catch(() => undefined);
+});

package/lib/utils/sdk-log.d.ts

@@ -0,0 +1,28 @@
+export type SDKLogLevel = "off" | "error" | "warn" | "info" | "debug" | "trace";
+export interface SDKLogEntry {
+    ts: number;
+    level: Exclude<SDKLogLevel, "off">;
+    module: string;
+    action: string;
+    devId?: string;
+    traceId?: string;
+    duration?: number;
+    data?: Record<string, unknown>;
+    error?: {
+        message: string;
+        code?: number;
+        stack?: string;
+    };
+}
+export type SDKLogSink = (entry: SDKLogEntry) => void;
+export interface SDKLogConfig {
+    level: SDKLogLevel;
+    sink?: SDKLogSink;
+    console?: boolean;
+}
+type SDKLogPayload = Omit<SDKLogEntry, "ts" | "level" | "module" | "action" | "error"> & {
+    error?: unknown;
+};
+export declare function setSDKLogConfig(next: Partial<SDKLogConfig>): void;
+export declare function sdkLog(level: Exclude<SDKLogLevel, "off">, module: string, action: string, payload?: SDKLogPayload): void;
+export {};

package/lib/utils/sdk-log.js

@@ -0,0 +1,128 @@
+const levelWeights = {
+    off: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+    trace: 5,
+};
+let config = {
+    level: "warn",
+    console: false,
+};
+const sensitiveKeyPattern = /password|pwd|token|key|secret|ins|devUnlockId|raw|dpValue/i;
+let defaultLogManager;
+function getDefaultLogManager() {
+    if (defaultLogManager) {
+        return defaultLogManager;
+    }
+    try {
+        if (typeof ty === "undefined") {
+            return undefined;
+        }
+        const getLogManager = ty.getLogManager;
+        if (typeof getLogManager === "function") {
+            defaultLogManager = getLogManager({ tag: "lock-sdk" });
+        }
+    }
+    catch {
+        defaultLogManager = null;
+    }
+    return defaultLogManager ?? undefined;
+}
+function getDefaultSink() {
+    const manager = getDefaultLogManager();
+    if (!manager) {
+        return undefined;
+    }
+    return (entry) => {
+        const message = JSON.stringify(entry);
+        if (typeof manager[entry.level] === "function") {
+            manager[entry.level]({
+                message,
+            });
+        }
+        else {
+            manager.log({ message });
+        }
+    };
+}
+function sanitize(value) {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(sanitize);
+    }
+    return Object.keys(value).reduce((acc, key) => {
+        acc[key] = sensitiveKeyPattern.test(key)
+            ? "[REDACTED]"
+            : sanitize(value[key]);
+        return acc;
+    }, {});
+}
+function normalizeError(error) {
+    if (!error) {
+        return undefined;
+    }
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    if (typeof error === "object") {
+        const err = error;
+        const rawCode = err["code"] ?? err["errorCode"];
+        const code = typeof rawCode === "number"
+            ? rawCode
+            : typeof rawCode === "string"
+                ? Number(rawCode)
+                : undefined;
+        return {
+            message: String(err["message"] ?? err["errorMsg"] ?? "Unknown error"),
+            code: Number.isFinite(code) ? code : undefined,
+        };
+    }
+    return {
+        message: String(error),
+    };
+}
+export function setSDKLogConfig(next) {
+    config = {
+        ...config,
+        ...next,
+    };
+}
+export function sdkLog(level, module, action, payload = {}) {
+    if (levelWeights[config.level] < levelWeights[level]) {
+        return;
+    }
+    const entry = {
+        ts: Date.now(),
+        level,
+        module,
+        action,
+        devId: payload.devId,
+        traceId: payload.traceId,
+        duration: payload.duration,
+        data: sanitize(payload.data),
+        error: normalizeError(payload.error),
+    };
+    try {
+        const sink = config.sink ?? getDefaultSink();
+        sink?.(entry);
+        if (config.console) {
+            let fn = console.log;
+            if (level === "error") {
+                fn = console.error;
+            }
+            else if (level === "warn") {
+                fn = console.warn;
+            }
+            fn("[lock-sdk]", level, entry);
+        }
+    }
+    catch (error) {
+    }
+}

package/package.json

@@ -1,17 +1,38 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.1.3-beta.9",
+  "version": "1.2.0-beta.1",
   "files": [
     "lib",
     "LICENSE.md"
   ],
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./fit": {
+      "types": "./lib/fit.d.ts",
+      "import": "./lib/fit.js",
+      "default": "./lib/fit.js"
+    },
+    "./screen": {
+      "types": "./lib/screen.d.ts",
+      "import": "./lib/screen.js",
+      "default": "./lib/screen.js"
+    }
+  },
   "scripts": {
-    "build": "tsc",
-    "compile": "tsc",
+    "build": "tsc && tsc-alias -p tsconfig.json",
+    "compile": "tsc && tsc-alias -p tsconfig.json",
     "lint": "eslint . --max-warnings 0",
-    "check-types": "tsc --noEmit"
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "audit:api-tests": "vitest run _tests/api-test-audit.test.ts",
+    "audit:api-tests:update": "UPDATE_API_AUDIT=1 vitest run _tests/api-test-audit.test.ts"
   },
   "maintainers": [
     "tuya_npm",
@@ -23,9 +44,7 @@
   "devDependencies": {
     "@turbo/gen": "^2.4.0",
     "@types/node": "^22.13.0",
-    "@types/react": "19.0.8",
-    "eslint": "^9.21.0",
-    "typescript": "5.7.3"
+    "@types/react": "19.0.8"
   },
   "peerDependencies": {
     "react": "^19.0.0"

package/lib/capability.d.ts

@@ -1,4 +0,0 @@
-import { DeviceAdvancedAbility } from "./interface";
-export declare const isActiveThread: () => Promise<boolean>;
-export declare const isShareThead: () => boolean;
-export declare const getDeviceAdvancedAbilities: () => Promise<DeviceAdvancedAbility>;

package/lib/config/index.d.ts

@@ -1,28 +0,0 @@
-import { ProductCommunicationType } from "../constant";
-import { CapabilityInfo, DeviceInfo, DpSchema, RemotePermission, DeviceStatus, LockSDKOption } from "../interface";
-declare const config: {
-    devInfo: DeviceInfo;
-    dpSchema: Record<string, DpSchema>;
-    codesById: Record<string, string>;
-    idsByCode: Record<string, number>;
-    remoteOpenEnabled: boolean;
-    remoteOpenPermission: RemotePermission;
-    capabilities: CapabilityInfo | null;
-    onlineType: number;
-    communication: ProductCommunicationType[];
-    supportBigData: boolean;
-    passwordDigitalBase: number;
-    passwordSupportZero: boolean;
-    strictMode: boolean;
-    imageAngle: number;
-    videoAngle: number;
-    supportMultipleFace: boolean;
-    supportOfflineDps: boolean;
-    preFetch: boolean;
-    deviceStatus: DeviceStatus;
-};
-type UpdateConfigParams = Omit<LockSDKOption, "devInfo" | "deviceId" | "preFetch">;
-export declare const updateConfig: (options: UpdateConfigParams) => void;
-export declare const hasCapability: (capability: ProductCommunicationType) => boolean;
-export declare const hasDp: (dpCode: string) => boolean;
-export default config;

package/lib/config/index.js

@@ -1,41 +0,0 @@
-const config = {
-    devInfo: {},
-    dpSchema: {},
-    codesById: {},
-    idsByCode: {},
-    remoteOpenEnabled: false,
-    remoteOpenPermission: "everyOne",
-    capabilities: null,
-    onlineType: 0,
-    communication: [0],
-    supportBigData: false,
-    passwordDigitalBase: 10,
-    passwordSupportZero: true,
-    strictMode: true,
-    imageAngle: 0,
-    videoAngle: 0,
-    supportMultipleFace: false,
-    supportOfflineDps: false,
-    preFetch: false,
-    deviceStatus: {
-        type: "offline",
-        connectEnable: false,
-        onlineType: "none",
-        isWifiActive: false,
-    },
-};
-export const updateConfig = (options) => {
-    Object.keys(options).forEach((key) => {
-        const value = options[key];
-        if (value !== undefined) {
-            config[key] = value;
-        }
-    });
-};
-export const hasCapability = (capability) => {
-    return config.communication.includes(capability);
-};
-export const hasDp = (dpCode) => {
-    return !!config.dpSchema[dpCode];
-};
-export default config;

package/lib/event.d.ts

@@ -1,2 +0,0 @@
-export declare const SLEEP_EVENT = "sleep_event";
-export declare const DEVICE_STATUS_CHANGE_EVENT = "device_status_change";

package/lib/event.js

@@ -1,2 +0,0 @@
-export const SLEEP_EVENT = "sleep_event";
-export const DEVICE_STATUS_CHANGE_EVENT = "device_status_change";

package/lib/linkage.d.ts

@@ -1,8 +0,0 @@
-export declare const getRemainingInfo: () => Promise<{
-    message: number;
-    phone: number;
-}>;
-export declare const getDoorbellService: () => Promise<import("./api/linkage").LinkageRule | undefined>;
-export declare const enableDoorbellService: () => Promise<void>;
-export declare const disableDoorbellService: () => Promise<void>;
-export declare const toSetDoorbellService: () => Promise<void>;