@ibiz-template/vue3-util 0.2.11 → 0.2.12

package/out/util/route/route.js

@@ -1,385 +0,0 @@
-import { notNilEmpty } from 'qx-util';
-import { RuntimeError } from '@ibiz-template/core';
-import qs from 'qs';
-import { useRoute } from 'vue-router';
-import { watch } from 'vue';
-import { calcDeCodeNameById, getMatchResPath, ViewType, } from '@ibiz-template/runtime';
-/**
- * 获取自身的路由上下文，排除了部分不需要路由携带的参数
- *
- * @author lxm
- * @date 2023-03-14 02:07:41
- * @export
- * @param {IContext} context
- * @returns {*}  {IParams}
- */
-export function getOwnRouteContext(context) {
-    const ownContext = context.getOwnContext();
-    const excludeKeys = ['srfsessionid', 'srfappid'];
-    Object.keys(ownContext).forEach(key => {
-        if (excludeKeys.includes(key)) {
-            delete ownContext[key];
-        }
-    });
-    return ownContext;
-}
-/**
- * 计算资源上下文时，需要排除自身实体codeName的视图（导航类视图和多数据视图）
- * @return {*}
- * @author: zhujiamin
- * @Date: 2023-02-20 15:45:46
- */
-export const excludeViewTypes = [
-    ViewType.DE_GRID_VIEW,
-    ViewType.DE_GRID_EXP_VIEW,
-    ViewType.DE_LIST_VIEW,
-    ViewType.DE_LIST_EXP_VIEW,
-    ViewType.DE_DATA_VIEW,
-    ViewType.DE_DATAVIEW_EXP_VIEW,
-    ViewType.DE_CALENDAR_VIEW,
-    ViewType.DE_CALENDAR_EXP_VIEW,
-    ViewType.DE_CHART_VIEW,
-    ViewType.DE_CHART_EXP_VIEW,
-    ViewType.DE_KANBAN_VIEW,
-];
-/**
- * 计算资源路径,把首页后面的资源路径上下文算出来，并把第二层中对应的上下文删掉。
- * @author lxm
- * @date 2023-07-13 06:37:10
- * @export
- * @param {IRoutePath} routePath
- * @param {IContext} context
- * @param {string} appDataEntityId
- * @return {*}  {Promise<void>}
- */
-export async function calcResRoutePath(routePath, context, appDataEntityId) {
-    if (!appDataEntityId) {
-        // 无实体的视图清空资源上下文
-        routePath.pathNodes[0].context = undefined;
-    }
-    else {
-        const entity = await ibiz.hub.getAppDataEntity(appDataEntityId);
-        let match = getMatchResPath(context, entity);
-        // 有实体有没有匹配到的，补一个包含自身实体主键的match
-        if (!match) {
-            match = { path: '', keys: [entity.codeName.toLowerCase()] };
-        }
-        if (match) {
-            const currentContext = routePath.pathNodes[1].context;
-            const resContext = {};
-            // 资源路径不为空,二级视图的上下文删掉多余的资源上下文
-            match.keys.forEach(key => {
-                if (context && Object.prototype.hasOwnProperty.call(context, key)) {
-                    resContext[key] = context[key];
-                    if (currentContext) {
-                        delete currentContext[key];
-                    }
-                }
-            });
-            // 把资源路径填充到一级路由上
-            routePath.pathNodes[0].context = resContext;
-        }
-    }
-}
-/**
- * 生成route路径
- *
- * @author lxm
- * @date 2022-08-17 21:08:00
- * @export
- * @param {IAppView} appView 视图模型
- * @param {Route} route 路由对象
- * @param {(IContext | undefined)} [context] 上下文对象
- * @param {(IParams | undefined)} [_params] 视图参数
- * @returns {*}  {string}
- */
-export async function generateRoutePath(appView, route, context, params) {
-    const routePath = route2routePath(route);
-    // 如果上下文存在toRouteDepth时，使用上下文的层级，否则使用默认层级
-    let depth = 2; // 默认都是从二级开始计算
-    if (context.toRouteDepth) {
-        depth = context.toRouteDepth;
-        // 使用完后删除，避免添加到上下文里
-        delete context.toRouteDepth;
-    }
-    else if (ibiz.env.isMob) {
-        // 移动端默认补充home层级
-        routePath.pathNodes[0] = {
-            viewName: 'home',
-        };
-    }
-    // 删除目标层级和之后的路由，保留之前层级的路由
-    routePath.pathNodes.splice(depth - 1, routePath.pathNodes.length - depth + 1);
-    // 导航视图的导航参数,加在目标层级之前的一个层级的视图参数里
-    if (context.currentSrfNav) {
-        const currentNode = routePath.pathNodes[routePath.pathNodes.length - 1];
-        currentNode.params = currentNode.params || {};
-        currentNode.srfnav = context.currentSrfNav;
-        // 使用完后删除，避免添加到上下文里
-        delete context.currentSrfNav;
-    }
-    // 重定向视图跳转的一级首页路由
-    if (route.fullPath.startsWith('/appredirectview')) {
-        if (params === null || params === void 0 ? void 0 : params.srfindexname) {
-            routePath.pathNodes[0].viewName = params.srfindexname;
-            delete params.srfindexname;
-        }
-        else {
-            routePath.pathNodes[0].viewName = 'index';
-        }
-    }
-    // 计算目标视图path路径
-    routePath.pathNodes.push({
-        viewName: appView.codeName.toLowerCase(),
-        context: getOwnRouteContext(context),
-        params,
-    });
-    // 计算二级视图的资源路径加到index后面
-    if (depth === 2) {
-        await calcResRoutePath(routePath, context, appView.appDataEntityId);
-        // 多数据和导航视图，删除自身的主键上下文
-        if (excludeViewTypes.includes(appView.viewType)) {
-            const deName = calcDeCodeNameById(appView.appDataEntityId);
-            delete routePath.pathNodes[0].context[deName];
-        }
-    }
-    return { path: routePath2string(routePath) };
-}
-/**
- * 解析路由获取对应视图数据
- *
- * @author lxm
- * @date 2022-08-17 22:08:51
- * @export
- * @param {IApplication} appModel 视图模型
- * @param {Route} route 路由对象
- * @param {number} depth 层级
- * @returns {*}  {IRouteViewData}
- */
-export async function parseRouteViewData(route, depth) {
-    var _a;
-    // 解析路由的视图参数
-    const routePath = route2routePath(route);
-    // 获取对应层级的视图名称参数
-    let viewCodeName = routePath.pathNodes[depth - 1].viewName;
-    if (!viewCodeName) {
-        throw new RuntimeError(`第${depth}级路由不存在视图标识`);
-    }
-    if (viewCodeName === 'index') {
-        viewCodeName = ibiz.hub.defaultAppIndexViewName;
-    }
-    // 根据路由视图名称参数查询视图模型
-    const viewModel = await ibiz.hub.getAppView(viewCodeName);
-    // 找不到视图模型的返回空对象
-    if (!viewModel) {
-        throw new RuntimeError(`找不到视图${viewCodeName}`);
-    }
-    // !解析上下文参数,整合当前层级之前所有的上下文参数
-    const context = {};
-    // 合并appData里的应用上下文
-    if ((_a = ibiz.appData) === null || _a === void 0 ? void 0 : _a.context) {
-        Object.assign(context, ibiz.appData.context);
-    }
-    // 合并路由上下文
-    // 合并路由应用上下文
-    if (routePath.appContext) {
-        Object.assign(context, routePath.appContext);
-    }
-    // 逐层合并视图上下文,第一层首页不合，它的上下文是资源路径属于子视图。
-    if (depth !== 1) {
-        for (let index = 0; index < depth; index++) {
-            const pathNode = routePath.pathNodes[index];
-            if (notNilEmpty(pathNode.context)) {
-                Object.assign(context, pathNode.context);
-            }
-        }
-    }
-    // 最后一级路由对应的视图才会解析视图参数
-    const { params, srfnav } = routePath.pathNodes[depth - 1];
-    return {
-        viewModel,
-        context,
-        params,
-        srfnav,
-    };
-}
-/**
- * 路径字符串转换成路由路径对象
- *
- * @author lxm
- * @date 2022-08-18 11:08:08
- * @export
- * @param {string} pathStr 以/开头的路径，即router的path
- * @returns {*}  {IRoutePath}
- */
-export function route2routePath(route) {
-    // 一共匹配了几级路由
-    const depth = route.matched.length;
-    // 解析路径节点
-    const pathNodes = [];
-    for (let index = 1; index <= depth; index++) {
-        const viewName = route.path.split('/')[index * 2];
-        const paramsStr = route.params[`params${index}`];
-        /** 路由参数，默认是视图参数 */
-        let params;
-        /** 上下文参数 */
-        let context;
-        let srfnav;
-        // params为占位符时置空
-        if (!paramsStr || paramsStr === ibiz.env.routePlaceholder) {
-            params = undefined;
-        }
-        else {
-            // 首页上下文要解析
-            params = qs.parse(paramsStr, {
-                strictNullHandling: true,
-                delimiter: ';',
-            });
-        }
-        // 路由参数存在的时候，解析里面的上下文。
-        if (params) {
-            if (index === 1) {
-                // 首页的时候，路由上的参数是资源路径，属于上下文
-                context = params;
-                params = undefined;
-            }
-            else {
-                if (params.srfnavctx) {
-                    // 解析额外上下文
-                    context = JSON.parse(decodeURIComponent(params.srfnavctx));
-                    delete params.srfnavctx;
-                }
-                if (params.srfnav) {
-                    // 解析额外自身视图导航参数
-                    srfnav = params.srfnav;
-                    delete params.srfnav;
-                }
-            }
-        }
-        pathNodes.push({ viewName, context, params, srfnav });
-    }
-    // 解析应用上下文
-    let appContext;
-    if (route.params.appContext &&
-        route.params.appContext !== ibiz.env.routePlaceholder) {
-        appContext = qs.parse(route.params.appContext, {
-            strictNullHandling: true,
-            delimiter: ';',
-        });
-    }
-    return { appContext, pathNodes };
-}
-/**
- * 路由路径对象转路径字符串
- *
- * @author lxm
- * @date 2022-08-18 13:08:57
- * @export
- * @param {IRoutePath} routePath 路由路径对象
- * @returns {*}  {string}
- */
-export function routePath2string(routePath) {
-    let pathStr = '';
-    // 应用上下文
-    if (routePath.appContext) {
-        pathStr += `/${qs.stringify(routePath.appContext, {
-            delimiter: ';',
-            strictNullHandling: true,
-        })}`;
-    }
-    else {
-        pathStr += `/${ibiz.env.routePlaceholder}`;
-    }
-    // 每一层级的视图路由的拼装
-    routePath.pathNodes.forEach((pathNode, index) => {
-        pathStr += `/${pathNode.viewName}/`;
-        let routeParams = {};
-        // 首页路由
-        if (index === 0) {
-            if (notNilEmpty(pathNode.context)) {
-                // 对象转成a=11;b=222的格式，字符串直接附加在后面
-                routeParams = pathNode.context;
-            }
-        }
-        else {
-            // 非首页路由,视图参数直接放到路由参数上，上下文转换后放到路由参数的srfnavctx上
-            routeParams = notNilEmpty(pathNode.params) ? pathNode.params : {};
-            // 合并视图上下文
-            if (notNilEmpty(pathNode.context)) {
-                const objStr = JSON.stringify(pathNode.context);
-                // undefined 的vlaue会被JSON.stringify删除,可能会转成{}
-                if (objStr !== '{}') {
-                    routeParams.srfnavctx = encodeURIComponent(objStr);
-                }
-            }
-            // 合并视图导航参数
-            if (pathNode.srfnav) {
-                routeParams.srfnav = pathNode.srfnav;
-            }
-        }
-        const paramsStr = qs.stringify(routeParams, {
-            delimiter: ';',
-            strictNullHandling: true,
-            skipNulls: true,
-        });
-        // 把路由参数转换到路由路径上去
-        if (notNilEmpty(paramsStr)) {
-            pathStr += paramsStr;
-        }
-        else {
-            pathStr += ibiz.env.routePlaceholder;
-        }
-    });
-    return pathStr;
-}
-/**
- * 获取指定层级的路由路径
- * @author lxm
- * @date 2023-06-21 06:08:32
- * @export
- * @param {Route} route
- * @param {number} depth
- * @return {*}  {string}
- */
-export function getNestedRoutePath(route, depth, noSrfNav = true) {
-    // 当前路由层级低于指定层级的返回空
-    if (route.matched.length < depth) {
-        return '';
-    }
-    // 有名称的路由返回空，如login，404等
-    if (route.name) {
-        return route.path;
-    }
-    const routePath = route2routePath(route);
-    if (routePath.pathNodes.length < depth) {
-        // 当前路由层级比指定层级少时，直接返回空字符串
-        return route.path;
-    }
-    if (routePath.pathNodes.length > depth) {
-        // 删除depth后面的节点
-        routePath.pathNodes = routePath.pathNodes.slice(0, depth);
-    }
-    if (noSrfNav) {
-        // 删除至nav
-        delete routePath.pathNodes[depth - 1].srfnav;
-    }
-    return routePath2string(routePath);
-}
-/**
- * 监听路由的变更，每次变更后都会触发回调
- * 回调函数提供根据视图层级计算好的唯一标识currentKey，只有变了视图才需要刷新
- * @author lxm
- * @date 2023-05-09 12:52:36
- * @param {(args: { currentKey: string; fullPath: string }) => void} callback
- * @param {number} depth
- */
-export function onRouteChange(callback, depth) {
-    const route = useRoute();
-    if (!route) {
-        throw new RuntimeError('无法正确获取route,可能是依赖问题');
-    }
-    watch(() => route === null || route === void 0 ? void 0 : route.path, () => {
-        const currentKey = getNestedRoutePath(route, depth);
-        callback({ currentKey, fullPath: route.fullPath });
-    }, { immediate: true });
-}