@ray-js/lock-sdk 1.1.1-beta.2 → 1.1.1-beta.20

package/lib/unlock-method.js

@@ -1,19 +1,18 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { bindUnlockMethodToUser, bindUnlockMethodToUserByRecord, checkFreeUnlockMethods, createUnlockMethod, removeUnlockMethod, editUnlockMethod, fetchCreatePasswordSN, fetchFreeUnlockMethods, getUnlockMethodInfo, unbindMemberUnlockMethod, } from "./api/lock";
-import { getUserDetail } from "./api/user";
 import config from "./config";
 import dpCodes from "./config/dp-code";
 import { add as addMap, reportAdd as reportAddMap, remove as removeMap, reportRemove as reportRemoveMap, } from "./config/dp-map/unlock-method";
 import { add as addBigMap, reportAdd as reportAddBigMap, remove as removeBigMap, reportRemove as reportRemoveBigMap, } from "./config/dp-map/unlock-method-big";
-import { validConfigDpMap } from "./config/dp-map/common";
 import { getPermanentSetting, getUnlockMethodTypeByDpCode, getUnlockMethodTypeByType, isAdmin, parallelOnly, sleep, } from "./utils";
 import { getError } from "./utils/errors";
 import { publishDps } from "./utils/publishDps";
 import { encrypt } from "./utils/device";
 import emitter from "./utils/event";
-import { DPCHANGE, UNLOCK_METHOD_EVENT } from "./utils/constant";
-import { sendPhoneVerifyCode } from "./api";
+import { DPCHANGE, LoopTypes, UNLOCK_METHOD_EVENT } from "./utils/constant";
+import { getFileRemoteUrl, sendPhoneVerifyCode } from "./api";
 import { getUserInfo } from "./user";
+import { getDeviceAdvancedAbilities } from "./capability";
 const getAddUnlockError = (status) => {
     if (status >= 0 && status <= 10) {
         return getError(1015 + status);
@@ -21,7 +20,10 @@ const getAddUnlockError = (status) => {
     if (status === 0xfe) {
         return getError(1026);
     }
-    return getError(1016);
+    return {
+        ...getError(1016),
+        devCode: status,
+    };
 };
 export const getUnlockMethodDetail = async (id) => {
     const cloudData = await getUnlockMethodInfo({
@@ -30,6 +32,7 @@ export const getUnlockMethodDetail = async (id) => {
     });
     const detail = {
         isBound: cloudData.allocateFlag === 1,
+        type: getUnlockMethodTypeByDpCode(config.codesById[Number(cloudData.opmode)])?.type,
         phase: cloudData.phase,
         dpId: Number(cloudData.opmode),
         isSpecial: cloudData.unlockAttr === 1,
@@ -41,6 +44,7 @@ export const getUnlockMethodDetail = async (id) => {
         userType: cloudData.userType,
         notifyInfo: {
             appSend: !!cloudData.notifyInfo?.appSend,
+            msgSend: !!cloudData.notifyInfo?.msgPhone,
             msgPhone: cloudData.notifyInfo?.msgPhone,
             countryCode: cloudData.notifyInfo?.countryCode,
         },
@@ -48,15 +52,14 @@ export const getUnlockMethodDetail = async (id) => {
     return detail;
 };
 const getUnlockMethodBase = async (type, userId) => {
-    const { idsByCode, devInfo: { devId }, supportBigData, dpSchema, } = config;
+    const { idsByCode, devInfo: { devId }, supportBigData, } = config;
     const unlockMethodConfig = getUnlockMethodTypeByType(type);
     const addDpCode = supportBigData
         ? dpCodes.unlockMethodCreateW
         : dpCodes.unlockMethodCreate;
     const dpId = idsByCode[unlockMethodConfig.code];
     const [user, sn] = await Promise.all([
-        getUserDetail({
-            devId: devId,
+        getUserInfo({
             userId: userId,
         }),
         fetchCreatePasswordSN({
@@ -64,10 +67,40 @@ const getUnlockMethodBase = async (type, userId) => {
             dpId,
         }),
     ]);
-    const { userType, lockUserId, userTimeSet } = user;
+    const { userType, lockUserId, timeScheduleInfo } = user;
     let validConfig;
-    if (userTimeSet) {
-        validConfig = dpUtils.parse(userTimeSet, validConfigDpMap.childMap);
+    if (timeScheduleInfo) {
+        const { permanent, effectiveTime, expiredTime, scheduleDetails } = timeScheduleInfo;
+        if (permanent) {
+            validConfig = {
+                startTime: Math.floor((effectiveTime || +new Date()) / 1000),
+                endTime: Math.floor((expiredTime || 0x72bc9b7f) / 1000),
+                loop: LoopTypes.NONE,
+                loopConfig: 0,
+                weeks: [0, 0, 0, 0, 0, 0, 0],
+                days: [],
+                startHour: 0,
+                startMinute: 0,
+                endHour: 0,
+                endMinute: 0,
+            };
+        }
+        else {
+            validConfig = {
+                startTime: Math.floor((effectiveTime || +new Date()) / 1000),
+                endTime: Math.floor((expiredTime || 0x72bc9b7f) / 1000),
+                loop: scheduleDetails?.repeat ? LoopTypes.WEEK : LoopTypes.NONE,
+                loopConfig: 0,
+                weeks: scheduleDetails?.repeat
+                    ? scheduleDetails?.weeks
+                    : [0, 0, 0, 0, 0, 0, 0],
+                days: [],
+                startHour: Math.floor((scheduleDetails?.effectiveTime ?? 0) / 60),
+                startMinute: (scheduleDetails?.effectiveTime ?? 0) % 60,
+                endHour: Math.floor((scheduleDetails?.invalidTime ?? 0) / 60),
+                endMinute: (scheduleDetails?.invalidTime ?? 0) % 60,
+            };
+        }
     }
     else {
         validConfig = getPermanentSetting();
@@ -104,11 +137,14 @@ const checkSpecial = (isSpecial, params, oldSetting) => {
             if (!supportedPhone) {
                 throw getError(1057);
             }
-            else if (!params?.msgPhone) {
+            else if (!params?.msgSend) {
                 throw getError(1058);
             }
         }
-        if (supportedPhone && params?.msgPhone) {
+        if (supportedPhone && params?.msgSend) {
+            if (!params.msgPhone) {
+                throw getError(1066);
+            }
             if (!params.countryCode) {
                 throw getError(1056);
             }
@@ -121,9 +157,9 @@ const checkSpecial = (isSpecial, params, oldSetting) => {
         unlockAttr: isSpecial ? 1 : 0,
         notifyInfo: {
             appSend: !!params?.appSend,
-            msgPhone: supportedPhone ? params?.msgPhone : undefined,
-            countryCode: supportedPhone ? params?.countryCode : undefined,
-            msgPhoneVerifyCode: supportedPhone ? params?.verifyCode : undefined,
+            msgPhone: supportedPhone && params?.msgSend ? params?.msgPhone : undefined,
+            countryCode: supportedPhone && params?.msgSend ? params?.countryCode : undefined,
+            msgPhoneVerifyCode: supportedPhone && params?.msgSend ? params?.verifyCode : undefined,
         },
     };
 };
@@ -305,7 +341,8 @@ const handleAddReport = async (dps) => {
                         };
                     }
                 }
-                catch {
+                catch (err) {
+                    console.warn("AddUnlockMethod failed", err);
                     eventData = {
                         stage: "fail",
                         type,
@@ -344,6 +381,7 @@ export const startAddUnlockMethod = async (params) => {
     const res = await publishDps({
         [addDpCode]: dpUtils.format(dpData, addDpMap),
     }, {
+        timeout: params.timeout,
         checkReport: (dpData) => {
             if (typeof dpData[addDpCode] !== "undefined") {
                 const result = dpUtils.parse(dpData[addDpCode], addDpReportMap);
@@ -369,6 +407,7 @@ export const startAddUnlockMethod = async (params) => {
     });
     if (res.stage === 0) {
         monitoringAddReport({
+            timeout: params.timeout,
             unlockMethodConfig,
             total: res.total,
             dpCode: addDpCode,
@@ -440,7 +479,7 @@ export const deleteUnlockMethod = parallelOnly(async (id) => {
         admin: isAdmin(userType),
         memberId: lockUserId,
         unlockId,
-        target: 1,
+        operation: 1,
     };
     const res = await publishDps({
         [removeDPCode]: dpUtils.format(dpData, (config.supportBigData ? removeBigMap : removeMap)),
@@ -560,3 +599,49 @@ export const onAddUnlockMethod = (listener) => {
 export const offAddUnlockMethod = (listener) => {
     emitter.off(UNLOCK_METHOD_EVENT, listener);
 };
+const guileTypeMap = {
+    card: ["addCard", "addCardPic"],
+    finger: ["addFingerprint", "addFingerprintPic"],
+    face: ["addFace", "addFacePic"],
+    fingerVein: ["addFingervein", "addFingerveinPic"],
+    hand: ["addPalmvein", "addPalmveinPic"],
+    eye: ["addIris", "addIrisPic"],
+};
+export const getUnlockGuide = async (type) => {
+    if (type === "password") {
+        return null;
+    }
+    const { unlockGuide } = await getDeviceAdvancedAbilities();
+    if (unlockGuide.support) {
+        const [videoKey, picKey] = guileTypeMap[type] || ["", ""];
+        const resources = [];
+        let videoUrlPath = "";
+        let picUrlPath = "";
+        if (unlockGuide.config[picKey]) {
+            picUrlPath = unlockGuide.config[picKey].url;
+            resources.push({
+                objectKey: picUrlPath,
+            });
+        }
+        if (unlockGuide.config[videoKey]) {
+            videoUrlPath = unlockGuide.config[videoKey].url;
+            resources.push({
+                objectKey: videoUrlPath,
+            });
+        }
+        if (resources.length === 0) {
+            return null;
+        }
+        const { signedUrls } = await getFileRemoteUrl({
+            biz: "hulk_video_tutorial_video",
+            resources,
+        });
+        const expireTime = Date.now() + 30 * 60 * 1000;
+        return {
+            videoUrl: signedUrls[videoUrlPath],
+            picUrl: signedUrls[picUrlPath],
+            expireTime,
+        };
+    }
+    return null;
+};

package/lib/user.d.ts

@@ -19,12 +19,12 @@ interface updateUserLimitTimeParams {
     effective?: EffectiveConfig;
     offlineUnlock?: boolean;
 }
-export declare const updateUserLimitTime: (params: updateUserLimitTimeParams) => Promise<boolean>;
+export declare const updateUserLimitTime: (params: updateUserLimitTimeParams) => Promise<true | undefined>;
 export declare const openAddFamilyUser: () => Promise<unknown>;
 export declare const openFamilyUserDetail: (userId: string) => Promise<undefined>;
 interface AddUserParams {
     name: string;
 }
-export declare const addUser: (params: AddUserParams) => Promise<import("./api/user").AddNormalUserResponse>;
+export declare const addUser: (params: AddUserParams) => Promise<void>;
 export declare const removeUser: (userId: string) => Promise<void>;
 export {};

package/lib/user.js

@@ -1,11 +1,11 @@
-import { getUserDetail, getUserList } from "./api/user";
+import { getUserDetailQuery, getUserList } from "./api/user";
 import config from "./config";
 import { update as updateMap, reportUpdate as reportUpdateMap, } from "./config/dp-map/unlock-method";
 import { update as updateMapBig, reportUpdate as reportUpdateMapBig, } from "./config/dp-map/unlock-method-big";
 import { publishDps } from "./utils/publishDps";
 import dpCodes from "./config/dp-code";
 import DpUtils from "@ray-js/tuya-dp-transform";
-import { getError } from "./utils/errors";
+import { getError, handleCloudError } from "./utils/errors";
 import { updateUserTimeSchedule, addNormalUser, removeNormalUser, } from "./api/user";
 import { validConfigDpMap } from "./config/dp-map/common";
 import { formatTimestampToMilliseconds, formatWeek, getPermanentSetting, isAdmin, isUseNearChannel, parseWeek, unlockMethodConfigs, validateEffectiveConfig, } from "./utils";
@@ -14,58 +14,61 @@ import { LoopTypes } from "./utils/constant";
 import { getCurrentUser } from "./state";
 import { deleteUser } from "./utils/user";
 import { UserType } from "./constant";
-const concactUserList = (list, result) => {
-    return list.reduce((acc, item) => {
-        const { timeScheduleInfo, unlockDetail, ...rest } = item;
-        let scheduleInfo = {
-            permanent: true,
-        };
-        if (!item.timeScheduleInfo.permanent &&
-            item.timeScheduleInfo.scheduleDetails &&
-            item.timeScheduleInfo.scheduleDetails.length > 0) {
-            Object.assign(timeScheduleInfo, {
-                effectiveTime: formatTimestampToMilliseconds(item.timeScheduleInfo.effectiveTime || 0),
-                expiredTime: formatTimestampToMilliseconds(item.timeScheduleInfo.expiredTime || 0),
-                scheduleDetails: {
-                    repeat: !item.timeScheduleInfo.scheduleDetails[0].allDay,
-                    effectiveTime: item.timeScheduleInfo.scheduleDetails[0].effectiveTime,
-                    invalidTime: item.timeScheduleInfo.scheduleDetails[0].invalidTime,
-                    timeZoneId: item.timeScheduleInfo.scheduleDetails[0].timeZoneId,
-                    weeks: parseWeek(item.timeScheduleInfo.scheduleDetails[0].workingDay),
-                },
-            });
-        }
-        let unlockDetails = unlockDetail.map((detail) => {
-            const unlockList = detail.unlockList.map((unlockItem) => {
-                return {
-                    unlockId: unlockItem.unlockId.split("-")[1],
-                    unlockName: unlockItem.unlockName,
-                    id: unlockItem.opModeId,
-                    isBound: unlockItem.allocateFlag === 1,
-                    photoUnlock: unlockItem.photoUnlock,
-                    isSpecial: unlockItem.unlockAttr === 1,
-                };
-            });
-            const unlockMethodConfig = unlockMethodConfigs.find((item) => item.code === detail.dpCode);
+const handleUserDetail = (user) => {
+    const { timeScheduleInfo, unlockDetail, ...rest } = user;
+    let scheduleInfo = {
+        permanent: true,
+    };
+    if (!timeScheduleInfo.permanent &&
+        timeScheduleInfo.scheduleDetails &&
+        timeScheduleInfo.scheduleDetails.length > 0) {
+        Object.assign(scheduleInfo, {
+            permanent: false,
+            effectiveTime: formatTimestampToMilliseconds(timeScheduleInfo.effectiveTime || 0),
+            expiredTime: formatTimestampToMilliseconds(timeScheduleInfo.expiredTime || 0),
+            scheduleDetails: {
+                repeat: !timeScheduleInfo.scheduleDetails[0].allDay,
+                effectiveTime: timeScheduleInfo.scheduleDetails[0].effectiveTime,
+                invalidTime: timeScheduleInfo.scheduleDetails[0].invalidTime,
+                timeZoneId: timeScheduleInfo.scheduleDetails[0].timeZoneId,
+                weeks: parseWeek(timeScheduleInfo.scheduleDetails[0].workingDay),
+            },
+        });
+    }
+    let unlockDetails = unlockDetail.map((detail) => {
+        const unlockList = detail.unlockList.map((unlockItem) => {
             return {
-                count: unlockList.length,
-                dpCode: detail.dpCode,
-                dpId: detail.dpId,
-                type: unlockMethodConfig.type,
-                unlockList,
+                unlockId: +unlockItem.unlockId.split("-")[1],
+                unlockName: unlockItem.unlockName,
+                id: unlockItem.opModeId,
+                isBound: unlockItem.allocateFlag === 1,
+                photoUnlock: unlockItem.photoUnlock,
+                isSpecial: unlockItem.unlockAttr === 1,
             };
         });
-        acc.push({
-            ...rest,
-            timeScheduleInfo: scheduleInfo,
-            unlockDetails,
-            isAccountUser: item.userListType === "group_user",
-        });
+        const unlockMethodConfig = unlockMethodConfigs.find((item) => item.code === detail.dpCode);
+        return {
+            count: unlockList.length,
+            dpCode: detail.dpCode,
+            dpId: detail.dpId,
+            type: unlockMethodConfig.type,
+            unlockList,
+        };
+    });
+    return {
+        ...rest,
+        timeScheduleInfo: scheduleInfo,
+        unlockDetails,
+        isAccountUser: user.userListType === "group_user",
+    };
+};
+const concactUserList = (list, result) => {
+    return list.reduce((acc, item) => {
+        acc.push(handleUserDetail(item));
         return acc;
     }, result);
 };
-export const getUsers = async (params) => {
-    const { page = 1, pageSize = 10, keyword = "" } = params || {};
+const getUserDpCodes = async () => {
     const currentUser = await getCurrentUser();
     const dps = [];
     if (currentUser.allOpenDps) {
@@ -77,6 +80,11 @@ export const getUsers = async (params) => {
             return acc;
         }, dps);
     }
+    return dps;
+};
+export const getUsers = async (params) => {
+    const { page = 1, pageSize = 10, keyword = "" } = params || {};
+    const dps = await getUserDpCodes();
     const res = await getUserList({
         dpCodes: dps.join(","),
         devId: config.devInfo.devId,
@@ -97,26 +105,24 @@ export const getUsers = async (params) => {
     };
 };
 export const getUserInfo = async (params) => {
-    const user = await getUserDetail({
+    const currentUser = await getCurrentUser();
+    const res = await getUserDetailQuery({
         devId: config.devInfo.devId,
         userId: params.userId,
+        dpIds: currentUser.allOpenDps,
     });
-    const data = await getUsers({
-        keyword: user.nickName,
-    });
-    const res = data.list.find((item) => item.userId === params.userId);
-    if (res) {
-        return res;
-    }
-    throw getError(1048);
+    return handleUserDetail(res);
 };
 export const updateUserLimitTime = async (params) => {
     const { userId, lockUserId, permanent, effective } = params;
     if (!permanent) {
         validateEffectiveConfig(effective);
     }
-    const { userType } = await getUserDetail({
-        devId: config.devInfo.devId,
+    const currentUser = await getCurrentUser();
+    if (!isAdmin(currentUser.userType)) {
+        throw getError(1069);
+    }
+    const { userType } = await getUserInfo({
         userId,
     });
     if (isAdmin(userType)) {
@@ -198,11 +204,11 @@ export const updateUserLimitTime = async (params) => {
                 ],
             },
         });
+        return true;
     }
     catch (e) {
-        throw getError(1012);
+        handleCloudError(e, 1012);
     }
-    return true;
 };
 export const openAddFamilyUser = async () => {
     const homeInfo = await getCurrentHomeInfo();
@@ -241,11 +247,8 @@ export const openFamilyUserDetail = async (userId) => {
         const url = `tuyaSmart://member_info?homeId=${homeId}&memberId=${userId}&role=${role}`;
         ty.router({
             url: url,
-            success: (d) => {
-                console.log("openFamilyUserDetail success");
-            },
             fail: (e) => {
-                console.log("openFamilyUserDetail fail", e);
+                console.error("openFamilyUserDetail fail", e);
             },
         });
         return;
@@ -259,17 +262,24 @@ export const addUser = async (params) => {
     if (!params.name) {
         throw getError(1009, "name");
     }
-    return addNormalUser({
-        devId: config.devInfo.devId,
-        name: params.name,
-    });
+    try {
+        await addNormalUser({
+            devId: config.devInfo.devId,
+            name: params.name,
+        });
+    }
+    catch (e) {
+        if (e?.innerError?.errorCode === "DEFINITION_PARAM_NAME_REPEAT") {
+            throw getError(1068);
+        }
+        throw e;
+    }
 };
 export const removeUser = async (userId) => {
     if (!config.supportBigData) {
         throw getError(1060);
     }
-    const res = await getUserDetail({
-        devId: config.devInfo.devId,
+    const res = await getUserInfo({
         userId,
     });
     if (isUseNearChannel()) {

package/lib/utils/device.d.ts

@@ -176,4 +176,5 @@ export declare const onAppShow: (cb: () => void) => void;
 export declare const offAppShow: (cb: () => void) => void;
 export declare const onAppHide: (cb: () => void) => void;
 export declare const offAppHide: (cb: () => void) => void;
+export declare const trackEvent: (event: string, data: Record<string, any>) => void;
 export {};

package/lib/utils/device.js

@@ -364,3 +364,9 @@ export const onAppHide = (cb) => {
 export const offAppHide = (cb) => {
     ty.offAppShow(cb);
 };
+export const trackEvent = (event, data) => {
+    ty.event({
+        eventId: event,
+        event: data,
+    });
+};

package/lib/utils/errors.d.ts

@@ -1,2 +1,3 @@
 import { ErrorData } from "../interface";
 export declare const getError: (code: number, ...places: string[]) => ErrorData;
+export declare const handleCloudError: (err: any, code?: number) => never;

package/lib/utils/errors.js

@@ -64,6 +64,10 @@ const errors = {
     1063: "Password length only supports 4-6 digits",
     1064: "Non-thread device, not supported in LAN connection to open and close locks",
     1065: "Cloud side has been deleted, but device side synchronization deletion failed",
+    1066: "Phone number cannot be empty",
+    1067: "Password limit reached within this period",
+    1068: "There is already a member with the same name",
+    1069: "No permission to modify member validity",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {
@@ -83,3 +87,36 @@ export const getError = (code, ...places) => {
         errorMsg: "unknow error",
     };
 };
+export const handleCloudError = (err, code) => {
+    if (err?.innerError?.errorCode) {
+        let error;
+        switch (err.innerError.errorCode) {
+            case "USER_PWD_ALREADY_EXIST":
+                error = getError(1037);
+                break;
+            case "LOCK_PWD_NAME_REPEAT":
+            case "OFFLINE_PWD_NAME_REPEAT":
+                error = getError(1038);
+                break;
+            case "START_END_DATE_NOT_RIGHT":
+                error = getError(1039);
+                break;
+            case "RECORD_NOT_EXIST":
+                error = getError(1040);
+                break;
+            case "OFFLINE_PWD_EXAUST_IN_PERIOD":
+                error = getError(1067);
+                break;
+            default:
+        }
+        if (error) {
+            error.errorMsg = err.innerError.errorMsg;
+            error.innerError = err.innerError;
+            throw error;
+        }
+    }
+    if (code) {
+        throw getError(code);
+    }
+    throw err;
+};

package/lib/utils/index.d.ts

@@ -107,7 +107,7 @@ 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) => 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>;

package/lib/utils/index.js

@@ -49,7 +49,8 @@ export function getCapabilities(capability) {
     });
 }
 export const formatWeek = (value) => {
-    return parseInt([...value].reverse().join(""), 2);
+    const temp = value.slice(0, 7);
+    return parseInt(temp.reverse().join(""), 2);
 };
 export const parseWeek = (value) => {
     return Number(value)
@@ -258,18 +259,20 @@ onBackgroundFetchData(preFetchKeys, (res) => {
     });
 });
 export const getDataWithPreFetch = async (key, apiCb) => {
-    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;
+    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 {
         }
-    }
-    catch {
     }
     return apiCb();
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.1.1-beta.2",
+  "version": "1.1.1-beta.20",
   "files": [
     "lib",
     "LICENSE.md"