@blocklet/meta 1.8.39 → 1.8.40

package/lib/parse-navigation-from-blocklet.d.ts

@@ -0,0 +1,53 @@
+declare const checkLink: (value: any) => boolean;
+/**
+ *
+ * @param {object} tree 需要深度遍历的数状结构
+ * @param {function} cb 每一个节点的回调函数，回调的参数：当前节点数据，父亲节点数据，{index:当前节点所属的数组中的序号，level: 当前节点所处的深度}
+ * @param {object} param 深度遍历的参数
+ * @param {string} param.key 孩子数组的 key 值
+ * @param {number} param.index 当前节点所属的数组中的序号
+ * @param {object} param.parent 当前节点的父节点
+ * @param {number} param.level 当前节点的深度
+ */
+declare function deepWalk(tree: any, cb?: () => void, { key, order }?: {
+    key?: string;
+    order?: string;
+}): void;
+/**
+ * 判断一个传入值是否属于一个 section
+ * @param {string | array} sections 需要判断的对象
+ * @param {string} section 目标 section
+ */
+declare function isMatchSection(sections: any, section: any): boolean;
+declare function joinLink(navigation: any, components: any): any;
+/**
+ * 将树状结构的导航列表进行扁平化处理
+ * @param {array} navigationList 树状结构的导航列表
+ * @param {object} params 配置参数
+ * @param {number} params.depth 扁平化的层级，默认为 1（全拍平）
+ * @param {function} params.transform 当发生拍平处理时
+ * @returns 扁平化后的导航列表
+ */
+declare function flatternNavigation(list?: any[], { depth, transform }?: {
+    depth?: number;
+    transform?: (v: any) => any;
+}): any[];
+/**
+ * 根据导航中每一个子菜单所属的 section，将原由的导航数据分离为多个导航数据（此时每一个导航 item 只会包含一个 section）
+ * @param {array} navigation 导航列表数据（树状结构，目前只适用于两层的树状结构）
+ * @returns
+ */
+declare function splitNavigationBySection(navigation: any): any[];
+/**
+ * 将导航数据进行层叠处理
+ * @param {array} list 扁平化的导航数据
+ * @returns 处理后的导航
+ */
+declare function nestNavigationList(list?: any[]): any[];
+declare function filterNavigation(navigationList: any, components?: any[]): any[];
+declare function parseNavigation(blocklet?: {}, options?: {}): {
+    navigationList: any[];
+    components: any[];
+    builtinList: any[];
+};
+export { parseNavigation, deepWalk, isMatchSection, nestNavigationList, filterNavigation, joinLink, checkLink, flatternNavigation, splitNavigationBySection, };

package/lib/parse-navigation-from-blocklet.js

@@ -0,0 +1,523 @@
+"use strict";
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitNavigationBySection = exports.flatternNavigation = exports.checkLink = exports.joinLink = exports.filterNavigation = exports.nestNavigationList = exports.isMatchSection = exports.deepWalk = exports.parseNavigation = void 0;
+const unionWith_1 = __importDefault(require("lodash/unionWith"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const isNil_1 = __importDefault(require("lodash/isNil"));
+const omit_1 = __importDefault(require("lodash/omit"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const url_join_1 = __importDefault(require("url-join"));
+const path_1 = __importDefault(require("path"));
+const is_absolute_url_1 = __importDefault(require("is-absolute-url"));
+const lodash_1 = require("lodash");
+const DEFAULT_SECTION = 'header';
+const BASE_PATH = '/';
+const DEFAULT_LINK = '/';
+const ID_SEPARATE = '/';
+/**
+ * 判断一个 url 是否为合法的 url 拼接路径
+ * /abc, /abc/bcd valid
+ * /abc, /abc//bcd invalid
+ * @param value 需要检查的 url path
+ * @returns boolean
+ */
+const checkUrlPath = (value) => {
+    return /^\/(?:[^/]+\/)*$/.test(value) || /^\/(?:[^/]+\/)*[^/]+$/.test(value);
+};
+const checkLink = (value) => {
+    if ((0, is_absolute_url_1.default)(value) || checkUrlPath(value)) {
+        return true;
+    }
+    return false;
+};
+exports.checkLink = checkLink;
+/**
+ *
+ * @param {object} tree 需要深度遍历的数状结构
+ * @param {function} cb 每一个节点的回调函数，回调的参数：当前节点数据，父亲节点数据，{index:当前节点所属的数组中的序号，level: 当前节点所处的深度}
+ * @param {object} param 深度遍历的参数
+ * @param {string} param.key 孩子数组的 key 值
+ * @param {number} param.index 当前节点所属的数组中的序号
+ * @param {object} param.parent 当前节点的父节点
+ * @param {number} param.level 当前节点的深度
+ */
+function deepWalk(tree, cb = () => { }, { key = 'children', order = 'first' } = {}) {
+    function walk(current, { index = 0, parent = null, level = 0 } = {}) {
+        if (Array.isArray(current)) {
+            current.forEach((item, i) => {
+                walk(item, { index: i, parent, level: level + 1 });
+            });
+        }
+        else if (current) {
+            if (order === 'first') {
+                cb(current, parent, { index, level });
+            }
+            walk(current[key], { parent: current, level });
+            if (order === 'last') {
+                cb(current, parent, { index, level });
+            }
+        }
+    }
+    walk(tree);
+}
+exports.deepWalk = deepWalk;
+/**
+ * 判断一个传入值是否属于一个 section
+ * @param {string | array} sections 需要判断的对象
+ * @param {string} section 目标 section
+ */
+function isMatchSection(sections, section) {
+    if (section === DEFAULT_SECTION && (0, isNil_1.default)(sections)) {
+        return true;
+    }
+    if (Array.isArray(sections)) {
+        return sections.includes(section);
+    }
+    return sections === section;
+}
+exports.isMatchSection = isMatchSection;
+function tryParseItem(item) {
+    try {
+        return JSON.parse(item);
+    }
+    catch (_a) {
+        return item;
+    }
+}
+function normalizeNavigationList(navigationList) {
+    return navigationList.map((item) => {
+        const tempData = Object.assign({}, item);
+        if (tempData.role) {
+            tempData.role = tryParseItem(tempData.role);
+        }
+        if (tempData.section) {
+            tempData.section = tryParseItem(tempData.section);
+        }
+        if (tempData.title) {
+            tempData.title = tryParseItem(tempData.title);
+        }
+        if (tempData.link) {
+            tempData.link = tryParseItem(tempData.link);
+        }
+        return tempData;
+    });
+}
+function optionalJoin(prefix = '/', url = '') {
+    if ((0, is_absolute_url_1.default)(url || '')) {
+        return url;
+    }
+    // remove last slash
+    const resultUrl = path_1.default.join(prefix, url || DEFAULT_LINK);
+    if (resultUrl.length > 1 && resultUrl.endsWith('/')) {
+        return resultUrl.slice(0, resultUrl.length - 1);
+    }
+    return resultUrl;
+}
+function smartJoinLink(_parentLink, _childLink, { strict = true } = {}) {
+    let parentLink = _parentLink;
+    let childLink = _childLink;
+    if (!strict) {
+        parentLink = parentLink || '/';
+        childLink = childLink || '/';
+    }
+    if ((0, lodash_1.isObject)(parentLink) && (0, lodash_1.isString)(childLink) && checkLink(childLink)) {
+        return Object.keys(parentLink).reduce((res, key) => {
+            res[key] = optionalJoin(parentLink[key], childLink);
+            return res;
+        }, {});
+    }
+    if ((0, lodash_1.isString)(parentLink) && checkLink(parentLink) && (0, lodash_1.isObject)(childLink)) {
+        return Object.keys(childLink).reduce((res, key) => {
+            res[key] = optionalJoin(parentLink, childLink[key]);
+            return res;
+        }, {});
+    }
+    if ((0, lodash_1.isString)(parentLink) && (0, lodash_1.isString)(childLink)) {
+        if (checkLink(parentLink) || checkLink(childLink)) {
+            return optionalJoin(parentLink, childLink);
+        }
+        return childLink;
+    }
+    if ((0, lodash_1.isObject)(parentLink) && (0, lodash_1.isObject)(childLink)) {
+        const keys = [...new Set([...Object.keys(parentLink), ...Object.keys(childLink)])];
+        return keys.reduce((res, key) => {
+            res[key] = optionalJoin(parentLink[key], childLink[key]);
+            return res;
+        }, {});
+    }
+    return childLink;
+}
+function joinLink(navigation, components) {
+    const copyNavigation = (0, cloneDeep_1.default)(navigation);
+    deepWalk(copyNavigation, (item, parent) => {
+        const component = item.component || item.child;
+        if (component) {
+            const findComponent = components.find((v) => v.name === component);
+            if (findComponent) {
+                item.link = smartJoinLink(findComponent.link, item.link, { strict: false });
+            }
+        }
+        else if (parent) {
+            item.link = smartJoinLink(parent.link, item.link);
+        }
+    }, { key: 'items' });
+    return copyNavigation;
+}
+exports.joinLink = joinLink;
+/**
+ * 将树状结构的导航列表进行扁平化处理
+ * @param {array} navigationList 树状结构的导航列表
+ * @param {object} params 配置参数
+ * @param {number} params.depth 扁平化的层级，默认为 1（全拍平）
+ * @param {function} params.transform 当发生拍平处理时
+ * @returns 扁平化后的导航列表
+ */
+function flatternNavigation(list = [], { depth = 1, transform = (v) => v } = {}) {
+    const copyList = (0, cloneDeep_1.default)(list);
+    const finalList = [];
+    deepWalk(copyList, (item, parent, { level }) => {
+        if (level >= depth) {
+            const { items = [] } = item;
+            if (items && Array.isArray(items) && items.length > 0) {
+                delete item.items;
+                const transformedItems = items.map((v) => transform(v, item));
+                if (parent) {
+                    parent.items.push(...transformedItems);
+                }
+                else {
+                    const tmpItem = transform((0, omit_1.default)(item, ['items']), parent);
+                    finalList.push(tmpItem, ...transformedItems);
+                }
+            }
+            else if (level === 1) {
+                const tmpItem = transform((0, omit_1.default)(item, ['items']), parent);
+                finalList.push(tmpItem);
+            }
+        }
+        else if (level === 1) {
+            finalList.push(item);
+        }
+    }, { key: 'items', order: 'last' });
+    return finalList;
+}
+exports.flatternNavigation = flatternNavigation;
+/**
+ * 将 blocklet 中的数据进行处理，获得当前应用的导航数据及组件数据
+ * @param {object} blocklet blocklet 应用实例对象
+ * @returns 导航数据及组件数据
+ */
+function parseBlockletNavigationList(blocklet = {}) {
+    const components = [];
+    /**
+     *
+     * @param {object} current 当前 blocklet 的数据
+     * @param {object} parent 当前 blocklet 的父组件数据
+     * @returns
+     */
+    function genNavigationListByBlocklet(current, parent = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const targetList = [];
+        const { children = [], meta = {} } = current;
+        const navigation = (0, cloneDeep_1.default)((meta === null || meta === void 0 ? void 0 : meta.navigation) || []);
+        if (((_b = (_a = current.meta) === null || _a === void 0 ? void 0 : _a.capabilities) === null || _b === void 0 ? void 0 : _b.navigation) !== false) {
+            targetList.push(...navigation);
+        }
+        const parentName = parent.name || '';
+        const parentBase = parent.mountPoint || BASE_PATH;
+        const currentName = current === blocklet ? '' : meta.name || '';
+        const currentBase = current === blocklet ? '' : current.mountPoint || BASE_PATH;
+        for (const child of children) {
+            const childName = child.meta.name;
+            const childBase = child.mountPoint;
+            const mergeName = [parentName, currentName, childName].filter(Boolean).join('.');
+            const childNavigation = child.meta.navigation || [];
+            const mergeBase = (0, url_join_1.default)(parentBase, currentBase, childBase);
+            if (((_d = (_c = child.meta) === null || _c === void 0 ? void 0 : _c.capabilities) === null || _d === void 0 ? void 0 : _d.navigation) !== false) {
+                components.push({
+                    did: child.meta.did,
+                    name: mergeName,
+                    link: mergeBase,
+                    title: child.meta.title || '',
+                    navigation: childNavigation.map((item) => (Object.assign({ 
+                        // 给每个 navigation 赋予一个 setion，用于在 autocomplete 提供依据 section 筛选的基础
+                        section: DEFAULT_SECTION }, item))),
+                });
+            }
+            // 在现有的 navigation 中判断是否存在 children
+            const matchNavigation = navigation.find((item) => {
+                if (item.component) {
+                    return item.component === childName;
+                }
+                return false;
+            });
+            // 如果存在，并且当前 navigation 未配置任何 link，则将 child mountpoint 给它
+            if (matchNavigation) {
+                if (!matchNavigation.link) {
+                    if (child.meta.navigation && child.meta.navigation.length > 0) {
+                        const items = genNavigationListByBlocklet(child, { mountPoint: currentBase, name: currentName });
+                        if (items.length > 0) {
+                            matchNavigation.items = (_e = matchNavigation.items) !== null && _e !== void 0 ? _e : [];
+                            matchNavigation.items.push(...items);
+                        }
+                    }
+                    else {
+                        matchNavigation.link = DEFAULT_LINK;
+                    }
+                }
+            }
+            else if (((_g = (_f = child.meta) === null || _f === void 0 ? void 0 : _f.capabilities) === null || _g === void 0 ? void 0 : _g.navigation) !== false) {
+                const childItems = genNavigationListByBlocklet(child, { mountPoint: currentBase, name: currentName });
+                // 否则动态注入一个 navigation
+                const tmpData = {
+                    title: child.meta.title,
+                    component: childName,
+                    // 动态注入的 navigation 需要一个默认的 id，blocklet.meta.id 是唯一的，可以用上这个值
+                    id: child.meta.did,
+                };
+                if (childItems.length > 0) {
+                    tmpData.items = childItems;
+                    tmpData.link = undefined;
+                }
+                else {
+                    tmpData.link = DEFAULT_LINK;
+                }
+                targetList.push(tmpData);
+            }
+        }
+        return targetList;
+    }
+    const navigationList = genNavigationListByBlocklet(blocklet);
+    return {
+        navigationList,
+        components,
+    };
+}
+function patchBuiltinNavigation(navigation) {
+    const copyNavigation = (0, cloneDeep_1.default)(navigation).filter((item) => item.id);
+    deepWalk(copyNavigation, (item, parent) => {
+        var _a;
+        // item.id = item.component || JSON.stringify(item.title) || nanoid();
+        if (item.items && item.items.length) {
+            for (let i = item.items.length - 1; i >= 0; i--) {
+                if (!item.items[i].id) {
+                    item.items.splice(i, 1);
+                }
+            }
+            // 如果 items 全都不符合规范，保留 item 本身，为其增加一个默认的链接
+            if (item.items.length === 0) {
+                if (item.component) {
+                    item.link = item.link || DEFAULT_LINK;
+                }
+            }
+        }
+        if (parent) {
+            item.parent = parent.id;
+            // 由于默认设置的 id(在 blocklet.yml 中手动赋予的存在重复的可能性比较大，所以通过 `/` 拼接父节点的 id，可以大大降低重复的概率)
+            item.id = [parent.id, item.id].join(ID_SEPARATE);
+        }
+        item.from = item.from || 'yaml';
+        item.visible = (_a = item.visible) !== null && _a !== void 0 ? _a : true;
+    }, { key: 'items' });
+    return copyNavigation;
+}
+/**
+ * 将多层结构的导航列表压缩至指定最大深度的树状结构
+ * @param {array} navigation 树状结构的导航列表数据
+ * @param {number} depth 压缩的层级
+ * @returns 压缩后的树状结构导航列表数据
+ */
+function compactNavigation(navigation, depth = 2) {
+    const copyNavigation = (0, cloneDeep_1.default)(navigation);
+    const resData = flatternNavigation(copyNavigation, {
+        depth,
+        transform: (item, parent) => {
+            var _a;
+            if (parent) {
+                if (!item._parent) {
+                    item._parent = parent.id;
+                    if (!parent.component) {
+                        item.link = smartJoinLink(parent.link, item.link);
+                    }
+                }
+                item.section = item.section || parent.section || [DEFAULT_SECTION];
+                item.visible = (_a = item.visible) !== null && _a !== void 0 ? _a : parent.visible;
+            }
+            item.component = [parent.component, item.component].filter(Boolean).join('.');
+            return item;
+        },
+    });
+    deepWalk(resData, (item) => {
+        if (item.items && item.items.length > 0) {
+            item.items.reduceRight((all, cur) => {
+                if (cur._parent) {
+                    const index = item.items.findIndex((v) => v.id === cur._parent);
+                    if (index >= 0) {
+                        item.items.splice(index, 1);
+                    }
+                    delete cur._parent;
+                }
+                return null;
+            }, null);
+        }
+    }, { key: 'items' });
+    return resData;
+}
+/**
+ * 返回指定的导航中的子菜单（属于指定 section）
+ * @param {object} navigationItem 指定的某一个导航数据
+ * @param {string} section 指定的 section 区域
+ * @returns
+ */
+function getNavigationListBySection(navigationItem, section) {
+    if (section && Array.isArray(navigationItem.items)) {
+        return navigationItem.items
+            .filter((item) => {
+            // 如果当前子菜单没有 section，它的 section 应该跟随父菜单的 section
+            if ((0, isNil_1.default)(item.section)) {
+                return isMatchSection(navigationItem.section, section);
+            }
+            if (isMatchSection(item.section, section)) {
+                return true;
+            }
+            return false;
+        })
+            .map((item) => (Object.assign(Object.assign({}, item), { section })));
+    }
+    return [];
+}
+/**
+ * 根据导航中每一个子菜单所属的 section，将原由的导航数据分离为多个导航数据（此时每一个导航 item 只会包含一个 section）
+ * @param {array} navigation 导航列表数据（树状结构，目前只适用于两层的树状结构）
+ * @returns
+ */
+function splitNavigationBySection(navigation) {
+    const copyNavigation = (0, cloneDeep_1.default)(navigation);
+    const allNavigationList = [];
+    for (const navigationItem of copyNavigation) {
+        const baseNavigation = (0, cloneDeep_1.default)((0, omit_1.default)(navigationItem, ['items']));
+        const itemNavigationList = [];
+        // eslint-disable-next-line no-inner-declarations
+        function patchNavigationItem(item, section) {
+            const sectionNavigationList = getNavigationListBySection(item, section);
+            itemNavigationList.push(Object.assign(Object.assign({}, baseNavigation), { section, items: sectionNavigationList }));
+        }
+        if (Array.isArray(navigationItem.section)) {
+            for (const section of navigationItem.section) {
+                patchNavigationItem(navigationItem, section);
+            }
+        }
+        else if (navigationItem.section) {
+            const { section } = navigationItem;
+            patchNavigationItem(navigationItem, section);
+        }
+        else if (navigationItem.items && navigationItem.items.length > 0) {
+            const allSectionList = navigationItem.items.reduce((list, currentValue) => {
+                const { section = [DEFAULT_SECTION] } = currentValue || {};
+                list.push(...section);
+                return list;
+            }, []);
+            const sectionList = [...new Set(allSectionList)];
+            for (const section of sectionList) {
+                patchNavigationItem(navigationItem, section);
+            }
+        }
+        else {
+            itemNavigationList.push(Object.assign(Object.assign({}, navigationItem), { section: DEFAULT_SECTION }));
+        }
+        allNavigationList.push(...itemNavigationList);
+    }
+    return allNavigationList;
+}
+exports.splitNavigationBySection = splitNavigationBySection;
+/**
+ * 将导航数据进行层叠处理
+ * @param {array} list 扁平化的导航数据
+ * @returns 处理后的导航
+ */
+function nestNavigationList(list = []) {
+    const cloneList = (0, cloneDeep_1.default)(list);
+    cloneList.reduceRight((res, item, index) => {
+        if (item.parent) {
+            const parent = cloneList.find((i) => {
+                if (item.section && i.section) {
+                    return i.section === item.section && i.id === item.parent;
+                }
+                return i.id === item.parent;
+            });
+            if (parent) {
+                if (!parent.items)
+                    parent.items = [];
+                // 由于 reduceRight 是从后向前遍历，所以后遍历到的其实顺序在前面
+                parent.items = [item, ...parent.items];
+            }
+            cloneList.splice(index, 1);
+        }
+        return null;
+    }, null);
+    return cloneList;
+}
+exports.nestNavigationList = nestNavigationList;
+function filterNavigation(navigationList, components = []) {
+    const fullNavigation = nestNavigationList(navigationList);
+    deepWalk(fullNavigation, (item) => {
+        if (item === null || item === void 0 ? void 0 : item.component) {
+            if (!components.some((x) => x.name === item.component)) {
+                item.visible = false;
+            }
+        }
+        if (item.items && item.items.length) {
+            for (let i = item.items.length - 1; i >= 0; i--) {
+                if (item.items[i].visible === false) {
+                    item.items.splice(i, 1);
+                }
+            }
+        }
+    }, { key: 'items' });
+    return fullNavigation.filter((item) => item.visible !== false);
+}
+exports.filterNavigation = filterNavigation;
+function parseNavigation(blocklet = {}, options = {}) {
+    var _a;
+    const { beforeProcess = (v) => v } = options;
+    const { navigationList: builtinNavigation, components } = parseBlockletNavigationList(blocklet);
+    const customNavigationList = ((_a = blocklet === null || blocklet === void 0 ? void 0 : blocklet.settings) === null || _a === void 0 ? void 0 : _a.navigations) || [];
+    const compactedNavigation = compactNavigation(beforeProcess(builtinNavigation));
+    const patchedNavigation = patchBuiltinNavigation(compactedNavigation);
+    const splitNavigation = splitNavigationBySection(patchedNavigation);
+    // 将 footer-social, footer-bottom, sessionManager 的二级菜单提升为一级菜单
+    const levelUpNavigation = splitNavigation.reduce((all, cur) => {
+        if (['bottom', 'social', 'sessionManager'].includes(cur.section)) {
+            if (cur.items && cur.items.length > 0) {
+                all.push(...cur.items.map((x) => {
+                    const { section } = cur;
+                    const link = smartJoinLink(cur.link, x.link);
+                    const component = [cur.component, x.component].filter(Boolean).join('.');
+                    return Object.assign(Object.assign({}, x), { section, link, component, parent: '' });
+                }));
+                return all;
+            }
+        }
+        all.push(cur);
+        return all;
+    }, []);
+    const flatNavigation = flatternNavigation(levelUpNavigation, {
+        transform(item, parent) {
+            let { component } = item;
+            if (parent === null || parent === void 0 ? void 0 : parent.component) {
+                component = [parent.component, item.component].filter(Boolean).join('.');
+            }
+            return Object.assign(Object.assign({}, item), { component });
+        },
+    });
+    const rawNavigation = (0, unionWith_1.default)(normalizeNavigationList(customNavigationList), flatNavigation, (prev, next) => {
+        const keys = ['id', 'section'];
+        return (0, isEqual_1.default)((0, pick_1.default)(prev, keys), (0, pick_1.default)(next, keys));
+    });
+    return { navigationList: rawNavigation, components, builtinList: flatNavigation };
+}
+exports.parseNavigation = parseNavigation;

package/lib/parse-navigation.js

@@ -46,6 +46,7 @@ const doParseNavigation = (navigation, blocklet, prefix = '/', _level = 1) => {
             }
             const item = {
                 title: nav.title,
+                id: undefined,
             };
             if (nav.section) {
                 item.section = nav.section;
@@ -82,6 +83,7 @@ const doParseNavigation = (navigation, blocklet, prefix = '/', _level = 1) => {
         const childTitle = child.meta.title || child.meta.name;
         const itemProto = {
             title: nav.title || childTitle,
+            id: undefined,
         };
         if (nav.section) {
             itemProto.section = nav.section;

package/lib/schema.js

@@ -21,10 +21,12 @@ const joi_1 = __importDefault(require("joi"));
 const cjk_length_1 = __importDefault(require("cjk-length"));
 const is_glob_1 = __importDefault(require("is-glob"));
 const joi_extension_semver_1 = require("joi-extension-semver");
+const is_var_name_1 = __importDefault(require("is-var-name"));
 const did_1 = __importDefault(require("./did"));
 const extension_1 = require("./extension");
 const name_1 = require("./name");
 const constants_1 = __importDefault(require("./constants"));
+const parse_navigation_from_blocklet_1 = require("./parse-navigation-from-blocklet");
 const cjkLength = cjk_length_1.default.default;
 const { BLOCKLET_GROUPS, BLOCKLET_PLATFORMS, BLOCKLET_ARCHITECTURES, BLOCKLET_INTERFACE_TYPES, BLOCKLET_INTERFACE_PROTOCOLS, BLOCKLET_ENTRY_FILE, BLOCKLET_BUNDLE_FILE, BLOCKLET_DEFAULT_PORT_NAME, BLOCKLET_DYNAMIC_PATH_PREFIX, BlockletGroup, BLOCKLET_LATEST_REQUIREMENT_SERVER, BLOCKLET_INTERFACE_TYPE_WEB, BLOCKLET_INTERFACE_TYPE_WELLKNOWN, BLOCKLET_APP_SPACE_ENDPOINTS, BLOCKLET_CONFIGURABLE_KEY, } = constants_1.default;
 const WELLKNOWN_PATH_PREFIX = '/.well-known';
@@ -34,6 +36,20 @@ const Joi = joi_1.default.extend(joi_extension_semver_1.semver)
     .extend(joi_extension_semver_1.semverRange)
     .extend(extension_1.fileExtension)
     .extend(extension_1.didExtension);
+const checkLinkHelper = (value, helper) => {
+    if ((0, parse_navigation_from_blocklet_1.checkLink)(value)) {
+        return value;
+    }
+    // @ts-expect-error
+    return helper.message('Invalid navigation link');
+};
+const checkId = (value, helper) => {
+    if (!value || (0, is_var_name_1.default)(value)) {
+        return value;
+    }
+    // @ts-expect-error
+    return helper.message('Invalid navigation id');
+};
 const titleSchema = Joi.string()
     .trim()
     .min(1)
@@ -297,21 +313,22 @@ const signatureSchema = Joi.object({
     unknownType: 'any',
 });
 exports.signatureSchema = signatureSchema;
+const localeList = ['en', 'zh', 'fr', 'ru', 'ar', 'es', 'de', 'pt', 'ja', 'hi'];
 const navigationItemProps = {
+    id: Joi.string().custom(checkId),
     title: Joi.alternatives()
-        .try(Joi.string(), Joi.object({
-        zh: Joi.string(),
-        en: Joi.string(),
-    }).min(1))
+        .try(Joi.string().min(1).max(MAX_TITLE_LENGTH), Joi.object()
+        .min(1)
+        .pattern(Joi.string().valid(...localeList), Joi.string().min(1).max(MAX_TITLE_LENGTH)))
         .required(),
-    link: Joi.alternatives().try(Joi.string(), Joi.object({
-        zh: Joi.string(),
-        en: Joi.string(),
-    }).min(1)),
+    link: Joi.alternatives().try(Joi.string().custom(checkLinkHelper), Joi.object()
+        .min(1)
+        .pattern(Joi.string().valid(...localeList), Joi.string().custom(checkLinkHelper))),
     component: Joi.string().min(1),
     section: Joi.array().items(Joi.string().min(1)).single(),
     role: Joi.array().items(Joi.string().min(1)).single(),
     icon: Joi.string().min(1),
+    visible: Joi.boolean(),
 };
 const navigationItemSchema = Joi.object(Object.assign(Object.assign({}, navigationItemProps), { items: Joi.array().items(Joi.object(Object.assign({}, navigationItemProps)).rename('child', 'component')) }))
     .rename('child', 'component')
@@ -320,7 +337,15 @@ const navigationItemSchema = Joi.object(Object.assign(Object.assign({}, navigati
     unknownType: 'any',
 });
 exports.navigationItemSchema = navigationItemSchema;
-const navigationSchema = Joi.array().items(navigationItemSchema).meta({
+const navigationSchema = Joi.array()
+    .items(navigationItemSchema)
+    .unique((a, b) => {
+    if (a.id && b.id) {
+        return a.id === b.id;
+    }
+    return false;
+})
+    .meta({
     className: 'TNavigation',
     unknownType: 'any',
 });
@@ -516,6 +541,7 @@ const blockletMetaProps = {
         didSpace: Joi.string()
             .valid(...Object.values(BLOCKLET_APP_SPACE_ENDPOINTS))
             .optional(),
+        navigation: Joi.boolean().default(true), // Should blocklet join navigation auto-merge process
     }).default({
         clusterMode: false,
         component: true,
@@ -574,9 +600,10 @@ const createBlockletSchema = (baseDir, _a = {}) => {
         .rename('children', 'components')
         .custom((data, helper) => {
         const { did, name } = data;
-        if ((0, did_1.default)(name) !== did) {
+        const expectDid = (0, did_1.default)(name);
+        if (expectDid !== did) {
             // @ts-expect-error
-            return helper.message(`name "${name}" does not match with did "${did}"`);
+            return helper.message(`the did of name "${name}" should be "${expectDid}"`);
         }
         return data;
     });

package/lib/types/schema.d.ts

@@ -14,6 +14,7 @@ export interface TBlockletMeta {
         clusterMode?: boolean;
         component?: boolean;
         didSpace?: 'required' | 'optional';
+        navigation?: boolean;
     };
     community?: string;
     components?: TComponent[];
@@ -173,30 +174,42 @@ export declare type TNavigation = TNavigationItem[];
 export interface TNavigationItem {
     component?: string;
     icon?: string;
+    id?: string;
     items?: {
         component?: string;
         icon?: string;
+        id?: string;
         link?: string | {
-            en?: string;
-            zh?: string;
+            /**
+             * Unknown Property
+             */
+            [x: string]: string;
         };
         role?: string[];
         section?: string[];
         title: string | {
-            en?: string;
-            zh?: string;
+            /**
+             * Unknown Property
+             */
+            [x: string]: string;
         };
+        visible?: boolean;
     }[];
     link?: string | {
-        en?: string;
-        zh?: string;
+        /**
+         * Unknown Property
+         */
+        [x: string]: string;
     };
     role?: string[];
     section?: string[];
     title: string | {
-        en?: string;
-        zh?: string;
+        /**
+         * Unknown Property
+         */
+        [x: string]: string;
     };
+    visible?: boolean;
 }
 export interface TPerson {
     email?: string;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.39",
+  "version": "1.8.40",
   "description": "Library to parse/validate/fix blocklet meta",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
@@ -24,26 +24,28 @@
   "author": "wangshijun <wangshijun2020@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/client": "1.8.39",
-    "@abtnode/constant": "1.8.39",
-    "@abtnode/util": "1.8.39",
-    "@arcblock/did": "1.18.18",
-    "@arcblock/did-ext": "1.18.18",
-    "@arcblock/did-util": "1.18.18",
-    "@arcblock/jwt": "1.18.18",
-    "@blocklet/constant": "1.8.39",
-    "@ocap/asset": "1.18.18",
-    "@ocap/mcrypto": "1.18.18",
-    "@ocap/types": "1.18.18",
-    "@ocap/util": "1.18.18",
-    "@ocap/wallet": "1.18.18",
+    "@abtnode/client": "1.8.40",
+    "@abtnode/constant": "1.8.40",
+    "@abtnode/util": "1.8.40",
+    "@arcblock/did": "1.18.26",
+    "@arcblock/did-ext": "1.18.26",
+    "@arcblock/did-util": "1.18.26",
+    "@arcblock/jwt": "1.18.26",
+    "@blocklet/constant": "1.8.40",
+    "@ocap/asset": "1.18.26",
+    "@ocap/mcrypto": "1.18.26",
+    "@ocap/types": "1.18.26",
+    "@ocap/util": "1.18.26",
+    "@ocap/wallet": "1.18.26",
     "ajv": "^8.11.0",
     "axios": "^0.27.2",
     "cjk-length": "^1.0.0",
     "debug": "^4.3.4",
     "fs-extra": "^10.1.0",
     "hosted-git-info": "3.0.8",
+    "is-absolute-url": "^3.0.3",
     "is-glob": "^4.0.3",
+    "is-var-name": "^2.0.0",
     "joi": "17.6.3",
     "joi-extension-semver": "^5.0.0",
     "js-yaml": "^4.1.0",
@@ -56,7 +58,7 @@
     "validate-npm-package-name": "^3.0.0"
   },
   "devDependencies": {
-    "@abtnode/client": "^1.8.37",
+    "@abtnode/client": "^1.8.39",
     "@arcblock/eslint-config-ts": "^0.2.3",
     "@types/express": "^4.17.14",
     "@types/jest": "^29.2.2",
@@ -77,5 +79,5 @@
     "ts-node": "^10.9.1",
     "typescript": "^4.8.4"
   },
-  "gitHead": "cf2223c4d9a999993b2be1c943dd75b4221593c3"
+  "gitHead": "336dbe0ad2cf512a322358899e56aab3668b1715"
 }