修复node包

node_modules/uni-simple-router/src/public/beforeProxyHook.ts

@@ -0,0 +1,46 @@
+import { voidFun } from '../helpers/utils';
+import { warn } from '../helpers/warn';
+import { Router, vueHookNameRule } from '../options/base';
+
+export function beforeProxyHook(
+    Vim:any,
+    router:Router
+):boolean {
+    const hookOptions = Vim.$options;
+    const {beforeProxyHooks} = router.options;
+    if (hookOptions == null) {
+        return false;
+    }
+    if (beforeProxyHooks == null) {
+        return false;
+    }
+    const keyArray = Object.keys(beforeProxyHooks) as Array<vueHookNameRule>;
+    for (let i = 0; i < keyArray.length; i++) {
+        const key = keyArray[i];
+        const hooksArray:Array<Function>|null = hookOptions[key];
+        if (hooksArray) {
+            const beforeProxyFun = beforeProxyHooks[key];
+            for (let j = 0; j < hooksArray.length; j++) {
+                const hookFun = hooksArray[j];
+                if (hookFun.toString().includes($npm_package_name)) {
+                    continue
+                }
+                const [oldHook] = hooksArray.splice(j, 1, function myReplace(this: any, ...args:Array<any>) {
+                    const pluginMarkId = $npm_package_name;
+                    voidFun(pluginMarkId);
+
+                    if (beforeProxyFun) {
+                        beforeProxyFun.call(this, args, (options) => {
+                            oldHook.apply(this, options)
+                        }, router);
+                    } else {
+                        oldHook.apply(this, args)
+                    }
+                });
+            }
+        } else {
+            warn(`beforeProxyHooks ===> 当前组件不适合${key}，或者 hook: ${key} 不存在，已为你规避处理，可以忽略。`, router)
+        }
+    }
+    return true
+}

node_modules/uni-simple-router/src/public/hooks.ts

@@ -0,0 +1,181 @@
+import {
+    Router,
+    hookListRule,
+    navtoRule,
+    reloadNavRule,
+    totalNextRoute,
+    hookToggle,
+    NAVTYPE,
+    navErrorRule,
+    objectAny
+} from '../options/base';
+import {
+    routesForMapRoute,
+    getDataType,
+    forMatNextToFrom,
+    getUniCachePage,
+    voidFun
+} from '../helpers/utils'
+import { navjump } from './methods';
+import { proxyH5Mount } from '../H5/proxyHook';
+import { addKeepAliveInclude } from '../H5/patch';
+import { tabIndexSelect } from '../app/appPatch';
+
+export const ERRORHOOK:Array<(error:navErrorRule, router:Router)=>void> = [
+    (error, router) => router.lifeCycle.routerErrorHooks[0](error, router)
+]
+export const HOOKLIST: hookListRule = [
+    (router, to, from, toRoute, next) => callHook(router.lifeCycle.routerBeforeHooks[0], to, from, router, next),
+    (router, to, from, toRoute, next) => callBeforeRouteLeave(router, to, from, next),
+    (router, to, from, toRoute, next) => callHook(router.lifeCycle.beforeHooks[0], to, from, router, next),
+    (router, to, from, toRoute, next) => callHook(toRoute.beforeEnter, to, from, router, next),
+    (router, to, from, toRoute, next) => callHook(router.lifeCycle.afterHooks[0], to, from, router, next, false),
+    (router, to, from, toRoute, next) => {
+        router.$lockStatus = false;
+        if (router.options.platform === 'h5') {
+            proxyH5Mount(router);
+            // 【Fixe】 https://github.com/SilurianYang/uni-simple-router/issues/316  2021年12月10日14:30:13
+            addKeepAliveInclude(router);
+        }
+        router.runId++;
+        return callHook(router.lifeCycle.routerAfterHooks[0], to, from, router, next, false)
+    }
+];
+
+export function callBeforeRouteLeave(
+    router:Router,
+    to:totalNextRoute,
+    from:totalNextRoute,
+    resolve:Function
+):void {
+    const page = getUniCachePage<objectAny>(0);
+    let beforeRouteLeave;
+    if (Object.keys(page).length > 0) {
+        let leaveHooks:Array<Function>|undefined|Function;
+        if (router.options.platform === 'h5') {
+            leaveHooks = (page as objectAny).$options.beforeRouteLeave;
+        } else {
+            if ((page as objectAny).$vm != null) {
+                leaveHooks = (page as objectAny).$vm.$options.beforeRouteLeave;
+            }
+        }
+        switch (getDataType<Array<Function>>((leaveHooks as Array<Function>))) {
+        case '[object Array]': // h5端表现
+            beforeRouteLeave = (leaveHooks as Array<Function>)[0];
+            beforeRouteLeave = beforeRouteLeave.bind(page)
+            break;
+        case '[object Function]': // 目前app端表现
+            beforeRouteLeave = (leaveHooks as Function).bind((page as objectAny).$vm);
+            break
+        }
+    }
+    return callHook(beforeRouteLeave, to, from, router, resolve);
+}
+
+export function callHook(
+    hook:Function|undefined,
+    to:totalNextRoute,
+    from: totalNextRoute,
+    router:Router,
+    resolve:Function,
+    hookAwait:boolean|undefined = true
+):void {
+    if (hook != null && hook instanceof Function) {
+        if (hookAwait === true) {
+            hook(to, from, resolve, router, false);
+        } else {
+            hook(to, from, () => {}, router, false);
+            resolve();
+        }
+    } else {
+        resolve();
+    }
+}
+
+export function onTriggerEachHook(
+    to:totalNextRoute,
+    from: totalNextRoute,
+    router:Router,
+    hookType:hookToggle,
+    next:(rule?: navtoRule|false)=>void,
+):void {
+    let callHookList:hookListRule = [];
+    switch (hookType) {
+    case 'beforeEach':
+        callHookList = HOOKLIST.slice(0, 3);
+        break;
+    case 'afterEach':
+        callHookList = HOOKLIST.slice(4);
+        break
+    case 'beforeEnter':
+        callHookList = HOOKLIST.slice(3, 4);
+        break;
+    }
+    transitionTo(router, to, from, 'push', callHookList, next);
+}
+
+export function transitionTo(
+    router:Router,
+    to:totalNextRoute,
+    from: totalNextRoute,
+    navType:NAVTYPE,
+    callHookList:hookListRule,
+    hookCB:Function
+) :void{
+    const {matTo, matFrom} = forMatNextToFrom<totalNextRoute>(router, to, from);
+    if (router.options.platform === 'h5') {
+        loopCallHook(callHookList, 0, hookCB, router, matTo, matFrom, navType);
+    } else {
+        loopCallHook(callHookList.slice(0, 4), 0, () => {
+            hookCB(() => { // 非H5端等他跳转完才触发最后两个生命周期
+                loopCallHook(callHookList.slice(4), 0, voidFun, router, matTo, matFrom, navType);
+            });
+        }, router, matTo, matFrom, navType);
+    }
+}
+
+export function loopCallHook(
+    hooks:hookListRule,
+    index:number,
+    next:Function,
+    router:Router,
+    matTo:totalNextRoute,
+    matFrom: totalNextRoute,
+    navType:NAVTYPE,
+): void|Function {
+    const toRoute = routesForMapRoute(router, matTo.path, ['finallyPathMap', 'pathMap']);
+    if (hooks.length - 1 < index) {
+        return next();
+    }
+    const hook = hooks[index];
+    const errHook = ERRORHOOK[0];
+    hook(router, matTo, matFrom, toRoute, (nextTo:reloadNavRule) => {
+        if (router.options.platform === 'app-plus') {
+            if (nextTo === false || (typeof nextTo === 'string' || typeof nextTo === 'object')) {
+                tabIndexSelect(matTo, matFrom);
+            }
+        }
+        if (nextTo === false) {
+            if (router.options.platform === 'h5') {
+                next(false);
+            }
+            errHook({ type: 0, msg: '管道函数传递 false 导航被终止!', matTo, matFrom, nextTo }, router)
+        } else if (typeof nextTo === 'string' || typeof nextTo === 'object') {
+            let newNavType = navType;
+            let newNextTo = nextTo;
+            if (typeof nextTo === 'object') {
+                const {NAVTYPE: type, ...moreTo} = nextTo;
+                newNextTo = moreTo;
+                if (type != null) {
+                    newNavType = type;
+                }
+            }
+            navjump(newNextTo, router, newNavType, {from: matFrom, next})
+        } else if (nextTo == null) {
+            index++;
+            loopCallHook(hooks, index, next, router, matTo, matFrom, navType)
+        } else {
+            errHook({ type: 1, msg: '管道函数传递未知类型，无法被识别。导航被终止！', matTo, matFrom, nextTo }, router)
+        }
+    });
+}

node_modules/uni-simple-router/src/public/methods.ts

@@ -0,0 +1,263 @@
+import {
+    NAVTYPE,
+    Router,
+    totalNextRoute,
+    objectAny,
+    routeRule,
+    reNavMethodRule,
+    rewriteMethodToggle,
+    navtypeToggle,
+    navErrorRule,
+    uniBackApiRule,
+    uniBackRule,
+    navRoute
+} from '../options/base'
+import {
+    queryPageToMap,
+    resolveQuery,
+    parseQuery
+} from './query'
+import {
+    voidFun,
+    paramsToQuery,
+    getUniCachePage,
+    routesForMapRoute,
+    copyData,
+    lockDetectWarn,
+    getDataType,
+    notRouteTo404,
+    deepDecodeQuery
+} from '../helpers/utils'
+import { transitionTo } from './hooks';
+import {createFullPath, createToFrom} from '../public/page'
+import {HOOKLIST} from './hooks'
+
+export function lockNavjump(
+    to:string|totalNextRoute|navRoute,
+    router:Router,
+    navType:NAVTYPE,
+    forceNav?:boolean,
+    animation?:uniBackApiRule|uniBackRule
+):void{
+    lockDetectWarn(router, to, navType, () => {
+        if (router.options.platform !== 'h5') {
+            router.$lockStatus = true;
+        }
+        navjump(to as totalNextRoute, router, navType, undefined, forceNav, animation);
+    }, animation);
+}
+export function navjump(
+    to:string|totalNextRoute,
+    router:Router,
+    navType:NAVTYPE,
+    nextCall?:{
+        from:totalNextRoute;
+        next:Function;
+    },
+    forceNav?:boolean,
+    animation?:uniBackApiRule|uniBackRule,
+    callHook:boolean|undefined = true
+) :void|never|totalNextRoute {
+    if (navType === 'back') {
+        let level:number = 1;
+        if (typeof to === 'string') {
+            level = +to;
+        } else {
+            level = to.delta || 1;
+            // 主要剥离事件函数
+            animation = {
+                ...animation || {},
+                ...(to as uniBackApiRule)
+            }
+        }
+        if (router.options.platform === 'h5') {
+            (router.$route as any).go(-level);
+
+            // Fixe  https://github.com/SilurianYang/uni-simple-router/issues/266   2021年6月3日11:14:38
+            // @ts-ignore
+            const success = (animation || {success: voidFun}).success || voidFun;
+            // @ts-ignore
+            const complete = (animation || {complete: voidFun}).complete || voidFun;
+            success({errMsg: 'navigateBack:ok'});
+            complete({errMsg: 'navigateBack:ok'});
+            return;
+        } else {
+            to = backOptionsBuild(router, level, animation);
+        }
+    }
+    const {rule} = queryPageToMap(to, router);
+    rule.type = navtypeToggle[navType];
+    const toRule = paramsToQuery(router, rule);
+    let parseToRule = resolveQuery(toRule as totalNextRoute, router);
+    if (router.options.platform === 'h5') {
+        if (navType !== 'push') {
+            navType = 'replace';
+        }
+        if (nextCall != null) { // next 管道函数拦截时 直接next即可
+            nextCall.next({
+                replace: navType !== 'push',
+                ...parseToRule
+            })
+        } else {
+            // Fixe  https://github.com/SilurianYang/uni-simple-router/issues/240   2021年3月7日14:45:36
+            if (navType === 'push' && Reflect.has(parseToRule, 'events')) {
+                if (Reflect.has(parseToRule, 'name')) {
+                    throw new Error(`在h5端上使用 'push'、'navigateTo' 跳转时，如果包含 events 不允许使用 name 跳转，因为 name 实现了动态路由。请更换为 path 或者 url 跳转！`);
+                } else {
+                    uni['navigateTo'](parseToRule, true, voidFun, forceNav);
+                }
+            } else {
+                (router.$route as any)[navType](parseToRule, (parseToRule as totalNextRoute).success || voidFun, (parseToRule as totalNextRoute).fail || voidFun)
+            }
+        }
+    } else {
+        let from:totalNextRoute = {path: ''};
+        if (nextCall == null) {
+            let toRoute = routesForMapRoute(router, parseToRule.path, ['finallyPathMap', 'pathMap']);
+            toRoute = notRouteTo404(router, toRoute, parseToRule, navType);
+            parseToRule = { ...toRoute, ...{params: {}}, ...parseToRule, ...{path: toRoute.path} }
+            from = createToFrom(parseToRule, router);
+        } else {
+            from = nextCall.from;
+        }
+        createFullPath(parseToRule, from);
+        if (callHook === false) {
+            return parseToRule;
+        }
+        transitionTo(router, parseToRule, from, navType, HOOKLIST, function(
+            callOkCb:Function
+        ):void {
+            uni[navtypeToggle[navType]](parseToRule, true, callOkCb, forceNav);
+        })
+    }
+}
+
+export function backOptionsBuild(
+    router:Router,
+    level:number,
+    animation:uniBackApiRule|uniBackRule|undefined = {},
+):totalNextRoute {
+    const toRule = createRoute(router, level, undefined, {NAVTYPE: 'back', ...animation});
+    const navjumpRule:totalNextRoute = {
+        ...animation,
+        path: toRule.path,
+        query: toRule.query,
+        delta: level
+    }
+    if (getDataType<any>(animation) === '[object Object]') {
+        const {animationDuration, animationType} = (animation as uniBackApiRule)
+        if (animationDuration != null) {
+            navjumpRule.animationDuration = animationDuration;
+        }
+        if (animationType != null) {
+            navjumpRule.animationType = animationType;
+        }
+
+        const {from} = (animation as uniBackRule)
+        if (from != null) {
+            navjumpRule.BACKTYPE = from;
+        }
+    }
+    return navjumpRule;
+}
+
+export function forceGuardEach(
+    router:Router,
+    navType:NAVTYPE|undefined = 'replaceAll',
+    forceNav:undefined|boolean = false
+):void|never {
+    if (router.options.platform === 'h5') {
+        throw new Error(`在h5端上使用：forceGuardEach 是无意义的，目前 forceGuardEach 仅支持在非h5端上使用`);
+    }
+    const currentPage = getUniCachePage<objectAny>(0);
+    if (Object.keys(currentPage).length === 0) {
+        (router.options.routerErrorEach as (error: navErrorRule, router:Router) => void)({
+            type: 3,
+            NAVTYPE: navType,
+            uniActualData: {},
+            level: 0,
+            msg: `不存在的页面栈，请确保有足够的页面可用，当前 level:0`
+        }, router);
+    }
+    const {route, options} = currentPage as objectAny;
+    lockNavjump({
+        path: `/${route}`,
+        query: deepDecodeQuery(options || {})
+    }, router, navType, forceNav);
+}
+
+export function createRoute(
+    router:Router,
+    level:number|undefined = 0,
+    orignRule?:totalNextRoute,
+    uniActualData:objectAny|undefined = {},
+):routeRule|never {
+    const route:routeRule = {
+        name: '',
+        meta: {},
+        path: '',
+        fullPath: '',
+        NAVTYPE: '',
+        query: {},
+        params: {},
+        BACKTYPE: (orignRule || {BACKTYPE: ''}).BACKTYPE || '' // v2.0.5 +
+    };
+
+    if (level === 19970806) { // 首次构建响应式 页面不存在 直接返回
+        return route
+    }
+    if (router.options.platform === 'h5') {
+        let vueRoute:totalNextRoute = {path: ''};
+        if (orignRule != null) {
+            vueRoute = orignRule;
+        } else {
+            vueRoute = (router.$route as objectAny).currentRoute;
+        }
+        const matRouteParams = copyData(vueRoute.params as objectAny);
+        delete matRouteParams.__id__;
+        const toQuery = parseQuery({...matRouteParams, ...copyData(vueRoute.query as objectAny)}, router);
+        vueRoute = {...vueRoute, query: toQuery}
+        route.path = vueRoute.path;
+        route.fullPath = vueRoute.fullPath || '';
+        route.query = deepDecodeQuery(vueRoute.query || {});
+        route.NAVTYPE = rewriteMethodToggle[vueRoute.type as reNavMethodRule || 'reLaunch'];
+    } else {
+        let appPage:objectAny = {};
+        if (orignRule != null) {
+            appPage = {...orignRule, openType: orignRule.type};
+        } else {
+            const page = getUniCachePage<objectAny>(level);
+            if (Object.keys(page).length === 0) {
+                const {NAVTYPE: _NAVTYPE, ..._args} = uniActualData;
+                const errorMsg:string = `不存在的页面栈，请确保有足够的页面可用，当前 level:${level}`;
+                (router.options.routerErrorEach as (error: navErrorRule, router:Router) => void)({
+                    type: 3,
+                    msg: errorMsg,
+                    NAVTYPE: _NAVTYPE,
+                    level,
+                    uniActualData: _args
+                }, router);
+                throw new Error(errorMsg);
+            }
+            // Fixes: https://github.com/SilurianYang/uni-simple-router/issues/196
+            const pageOptions:objectAny = (page as objectAny).options || {};
+            appPage = {
+                ...(page as objectAny).$page || {},
+                query: deepDecodeQuery(pageOptions),
+                fullPath: decodeURIComponent(((page as objectAny).$page || {}).fullPath || '/' + (page as objectAny).route)
+            }
+            if (router.options.platform !== 'app-plus') {
+                appPage.path = `/${(page as objectAny).route}`
+            }
+        }
+        const openType:reNavMethodRule|'navigateBack' = appPage.openType;
+        route.query = appPage.query;
+        route.path = appPage.path;
+        route.fullPath = appPage.fullPath;
+        route.NAVTYPE = rewriteMethodToggle[openType || 'reLaunch'];
+    }
+    const tableRoute = routesForMapRoute(router, route.path, ['finallyPathMap', 'pathMap'])
+    const perfectRoute = { ...route, ...tableRoute};
+    perfectRoute.query = parseQuery(perfectRoute.query, router);
+    return perfectRoute;
+}

node_modules/uni-simple-router/src/public/page.ts

@@ -0,0 +1,103 @@
+import { proxyHookName } from '../helpers/config';
+import { getDataType, getUniCachePage, deepClone} from '../helpers/utils';
+import { objectAny, pageTypeRule, Router, totalNextRoute, vueOptionRule } from '../options/base';
+import {createRoute} from './methods'
+import { stringifyQuery } from './query';
+
+export function createToFrom(
+    to:totalNextRoute,
+    router:Router,
+):totalNextRoute {
+    let fromRoute:totalNextRoute = {path: ''};
+    const page = getUniCachePage<Array<any>|objectAny>(0);
+    if (getDataType<Array<any>|objectAny>(page) === '[object Array]') {
+        fromRoute = deepClone<totalNextRoute>(to)
+    } else {
+        fromRoute = createRoute(router) as totalNextRoute;
+    }
+    return fromRoute;
+}
+
+export function createFullPath(
+    to:totalNextRoute,
+    from:totalNextRoute
+):void{
+    if (to.fullPath == null) {
+        const strQuery = stringifyQuery(to.query as objectAny);
+        to.fullPath = to.path + strQuery;
+    }
+    if (from.fullPath == null) {
+        const strQuery = stringifyQuery(from.query as objectAny);
+        from.fullPath = from.path + strQuery;
+    }
+}
+
+export function proxyPageHook(
+    vueVim:any,
+    router:Router,
+    pageType:pageTypeRule
+):void {
+    const hookDeps = router.proxyHookDeps;
+    const pageHook:vueOptionRule = vueVim.$options;
+    for (let i = 0; i < proxyHookName.length; i++) {
+        const hookName = proxyHookName[i];
+        const hookList = pageHook[hookName];
+        if (hookList) {
+            for (let k = 0; k < hookList.length; k++) {
+                const originHook = hookList[k];
+                if (originHook.toString().includes($npm_package_name)) {
+                    continue
+                }
+                const resetIndex = Object.keys(hookDeps.hooks).length + 1
+                const proxyHook = (...args:Array<any>):void => {
+                    hookDeps.resetIndex.push(resetIndex);
+                    hookDeps.options[resetIndex] = args;
+                }
+                const [resetHook] = hookList.splice(k, 1, proxyHook);
+                hookDeps.hooks[resetIndex] = {
+                    proxyHook,
+                    callHook: (enterPath:string) :void => {
+                        if (router.enterPath.replace(/^\//, '') !== enterPath.replace(/^\//, '') && pageType !== 'app') {
+                            return;
+                        }
+                        const options = hookDeps.options[resetIndex];
+                        resetHook.apply(vueVim, options);
+                    },
+                    resetHook: () :void => {
+                        hookList.splice(k, 1, resetHook)
+                    }
+                };
+            }
+        }
+    }
+}
+export function resetAndCallPageHook(
+    router:Router,
+    enterPath:string,
+    reset:boolean|undefined = true
+):void{
+    // Fixe: https://github.com/SilurianYang/uni-simple-router/issues/206
+    const pathInfo = enterPath.trim().match(/^(\/?[^\?\s]+)(\?[\s\S]*$)?$/);
+    if (pathInfo == null) {
+        throw new Error(`还原hook失败。请检查 【${enterPath}】 路径是否正确。`);
+    }
+    enterPath = pathInfo[1];
+    const proxyHookDeps = router.proxyHookDeps;
+    const resetHooksArray = proxyHookDeps.resetIndex
+    for (let i = 0; i < resetHooksArray.length; i++) {
+        const index = resetHooksArray[i];
+        const {callHook} = proxyHookDeps.hooks[index];
+        callHook(enterPath);
+    }
+    if (reset) {
+        resetPageHook(router);
+    }
+}
+export function resetPageHook(
+    router:Router
+) {
+    const proxyHookDeps = router.proxyHookDeps;
+    for (const [, {resetHook}] of Object.entries(proxyHookDeps.hooks)) {
+        resetHook();
+    }
+}

node_modules/uni-simple-router/src/public/query.ts

@@ -0,0 +1,200 @@
+import {
+    objectAny,
+    Router,
+    routesMapRule,
+    RoutesRule,
+    totalNextRoute
+} from '../options/base';
+import {
+    getDataType,
+    urlToJson,
+    routesForMapRoute,
+    getRoutePath,
+    assertDeepObject,
+    copyData,
+    getWildcardRule,
+    deepDecodeQuery
+} from '../helpers/utils'
+import {ERRORHOOK} from './hooks'
+import {warn} from '../helpers/warn'
+
+const encodeReserveRE = /[!'()*]/g
+const encodeReserveReplacer = (c:string) => '%' + c.charCodeAt(0).toString(16)
+const commaRE = /%2C/g
+
+const encode = (str:string) =>
+    encodeURIComponent(str)
+        .replace(encodeReserveRE, encodeReserveReplacer)
+        .replace(commaRE, ',')
+
+export function queryPageToMap(
+    toRule:string|totalNextRoute,
+    router:Router
+) :{
+    rule:totalNextRoute;
+    route:RoutesRule,
+    query:objectAny
+} {
+    let query:objectAny = {};
+    let route:RoutesRule|string = '';
+    let successCb = (toRule as totalNextRoute).success;
+    let failCb = (toRule as totalNextRoute).fail;
+    if (getDataType<string|totalNextRoute>(toRule) === '[object Object]') {
+        const objNavRule = (toRule as totalNextRoute);
+        if (objNavRule.path != null) {
+            const {path, query: newQuery} = urlToJson(objNavRule.path);
+            route = routesForMapRoute(router, path, ['finallyPathList', 'pathMap']);
+            query = {...newQuery, ...((toRule as totalNextRoute).query || {})};
+            objNavRule.path = path;
+            objNavRule.query = query;
+            delete (toRule as totalNextRoute).params;
+        } else if (objNavRule.name != null) {
+            route = (router.routesMap as routesMapRule).nameMap[objNavRule.name];
+            if (route == null) {
+                route = getWildcardRule(router, { type: 2, msg: `命名路由为：${objNavRule.name} 的路由，无法在路由表中找到！`, toRule});
+            } else {
+                query = (toRule as totalNextRoute).params || {};
+                delete (toRule as totalNextRoute).query;
+            }
+        } else {
+            route = getWildcardRule(router, { type: 2, msg: `${toRule} 解析失败，请检测当前路由表下是否有包含。`, toRule});
+        }
+    } else {
+        toRule = urlToJson((toRule as string)) as totalNextRoute;
+        route = routesForMapRoute(router, toRule.path, ['finallyPathList', 'pathMap'])
+        query = toRule.query as objectAny;
+    }
+    if (router.options.platform === 'h5') {
+        const {finallyPath} = getRoutePath(route as RoutesRule, router);
+        if (finallyPath.includes(':') && (toRule as totalNextRoute).name == null) {
+            ERRORHOOK[0]({ type: 2, msg: `当有设置 alias或者aliasPath 为动态路由时，不允许使用 path 跳转。请使用 name 跳转！`, route}, router)
+        }
+        const completeCb = (toRule as totalNextRoute).complete;
+        const cacheSuccess = (toRule as totalNextRoute).success;
+        const cacheFail = (toRule as totalNextRoute).fail;
+        if (getDataType<Function|undefined>(completeCb) === '[object Function]') {
+            const publicCb = function(this:any, args:Array<any>, callHook:Function|undefined):void {
+                if (getDataType<Function|undefined>(callHook) === '[object Function]') {
+                    (callHook as Function).apply(this, args);
+                }
+                (completeCb as Function).apply(this, args);
+            }
+            successCb = function(this:any, ...args:any):void{
+                publicCb.call(this, args, cacheSuccess);
+            };
+            failCb = function(this:any, ...args:any):void{
+                publicCb.call(this, args, cacheFail);
+            };
+        }
+    }
+    const rule = (toRule as totalNextRoute);
+    if (getDataType<Function|undefined>(rule.success) === '[object Function]') {
+        rule.success = successCb;
+    }
+    if (getDataType<Function|undefined>(rule.fail) === '[object Function]') {
+        rule.fail = failCb;
+    }
+    return {
+        rule,
+        route: (route as RoutesRule),
+        query
+    }
+}
+
+export function resolveQuery(
+    toRule:totalNextRoute,
+    router:Router
+):totalNextRoute {
+    let queryKey:'params'|'query' = 'query';
+    if (toRule.params as objectAny != null) {
+        queryKey = 'params';
+    }
+    if (toRule.query as objectAny != null) {
+        queryKey = 'query';
+    }
+    const query = copyData(toRule[queryKey] || {});
+    const {resolveQuery: userResolveQuery} = router.options;
+    if (userResolveQuery) {
+        const jsonQuery = userResolveQuery(query);
+        if (getDataType<objectAny>(jsonQuery) !== '[object Object]') {
+            warn('请按格式返回参数： resolveQuery?:(jsonQuery:{[propName: string]: any;})=>{[propName: string]: any;}', router)
+        } else {
+            toRule[queryKey] = jsonQuery;
+        }
+    } else {
+        const deepObj = assertDeepObject(query as objectAny);
+        if (!deepObj) {
+            return toRule;
+        }
+        const encode = JSON.stringify(query);
+        toRule[queryKey] = {
+            query: encode
+        }
+    }
+    return toRule
+}
+
+export function parseQuery(
+    query:objectAny,
+    router:Router,
+):objectAny {
+    const {parseQuery: userParseQuery} = router.options;
+    if (userParseQuery) {
+        query = userParseQuery(copyData(query));
+        if (getDataType<objectAny>(query) !== '[object Object]') {
+            warn('请按格式返回参数： parseQuery?:(jsonQuery:{[propName: string]: any;})=>{[propName: string]: any;}', router)
+        }
+    } else {
+        if (Reflect.get(query, 'query')) { // 验证一下是不是深度对象
+            let deepQuery = Reflect.get(query, 'query');
+            if (typeof deepQuery === 'string') {
+                try {
+                    deepQuery = JSON.parse(deepQuery);
+                } catch (error) {
+                    warn('尝试解析深度对象失败，按原样输出。' + error, router)
+                }
+            }
+            if (typeof deepQuery === 'object') {
+                return deepDecodeQuery(deepQuery);
+            }
+        }
+    }
+    return query
+}
+
+export function stringifyQuery(obj:objectAny): string {
+    const res = obj
+        ? Object.keys(obj)
+            .map(key => {
+                const val = obj[key]
+
+                if (val === undefined) {
+                    return ''
+                }
+
+                if (val === null) {
+                    return encode(key)
+                }
+
+                if (Array.isArray(val)) {
+                    const result:Array<any> = []
+                    val.forEach(val2 => {
+                        if (val2 === undefined) {
+                            return
+                        }
+                        if (val2 === null) {
+                            result.push(encode(key))
+                        } else {
+                            result.push(encode(key) + '=' + encode(val2))
+                        }
+                    })
+                    return result.join('&')
+                }
+
+                return encode(key) + '=' + encode(val)
+            })
+            .filter(x => x.length > 0)
+            .join('&')
+        : null
+    return res ? `?${res}` : ''
+}

node_modules/uni-simple-router/src/public/rewrite.ts

@@ -0,0 +1,177 @@
+import {
+    uniNavApiRule,
+    reNavMethodRule,
+    reNotNavMethodRule,
+    Router,
+    rewriteMethodToggle,
+    uniBackRule,
+    uniBackApiRule,
+    navtoRule,
+    totalNextRoute,
+    originMixins,
+    objectAny
+} from '../options/base'
+
+import {
+    routesForMapRoute,
+    getRoutePath,
+    getDataType,
+    notDeepClearNull,
+    resolveAbsolutePath,
+    getUniCachePage,
+    timeOut
+} from '../helpers/utils'
+
+import {
+    warn
+} from '../helpers/warn'
+
+import {uniOriginJump} from './uniOrigin'
+import { HomeNvueSwitchTab } from '../app/appPatch';
+
+const rewrite: Array<reNavMethodRule|reNotNavMethodRule> = [
+    'navigateTo',
+    'redirectTo',
+    'reLaunch',
+    'switchTab',
+    'navigateBack'
+];
+const cacheOldMethod:{
+    navigateTo:Function;
+    redirectTo:Function;
+    reLaunch:Function;
+    switchTab:Function;
+    navigateBack:Function;
+} = {
+    navigateTo: () => {},
+    redirectTo: () => {},
+    reLaunch: () => {},
+    switchTab: () => {},
+    navigateBack: () => {}
+}
+
+export function rewriteMethod(
+    router:Router
+): void {
+    if (router.options.keepUniOriginNav === false) {
+        rewrite.forEach(name => {
+            const oldMethod: Function = uni[name];
+            cacheOldMethod[name] = oldMethod;
+            uni[name] = async function(
+                params:originMixins|{from:string}|navtoRule,
+                originCall:boolean = false,
+                callOkCb?:Function,
+                forceNav?:boolean
+            ):Promise<void> {
+
+                if (originCall) {
+                    if (router.options.platform === 'app-plus') {
+                        await HomeNvueSwitchTab(router, (params as navtoRule), cacheOldMethod['reLaunch']);
+                    }
+                    uniOriginJump(router, oldMethod, name, params as originMixins, callOkCb, forceNav)
+
+                } else {
+                    if (router.options.platform === 'app-plus') {
+                        if (Object.keys(router.appMain).length === 0) {
+                            router.appMain = {
+                                NAVTYPE: name,
+                                path: (params as uniNavApiRule).url
+                            }
+                        }
+                    }
+                    callRouterMethod(params as uniNavApiRule, name, router);
+                }
+
+
+            };
+        })
+    }
+}
+function callRouterMethod(
+    option: uniNavApiRule|uniBackRule|uniBackApiRule,
+    funName:reNavMethodRule|reNotNavMethodRule,
+    router:Router
+): void {
+    if (router.options.platform === 'app-plus') {
+        let openType = null;
+        if (option) {
+            openType = (option as uniNavApiRule).openType;
+        }
+        if (openType != null && openType === 'appLaunch') {
+            funName = 'reLaunch'
+        }
+    }
+    if (funName === 'reLaunch' && JSON.stringify(option) === '{"url":"/"}') {
+        warn(
+            `uni-app 原生方法：reLaunch({url:'/'}) 默认被重写啦！你可以使用 this.$Router.replaceAll() 或者 uni.reLaunch({url:'/?xxx=xxx'})`,
+            router
+        );
+        funName = 'navigateBack';
+        option = {
+            from: 'backbutton'
+        }
+    }
+    if (funName === 'navigateBack') {
+        let level:number = 1;
+        if (option == null) {
+            option = {delta: 1};
+        }
+        if (getDataType<number|undefined>((option as uniBackApiRule).delta) === '[object Number]') {
+            level = ((option as uniBackApiRule).delta as number);
+        }
+        router.back(level, (option as uniBackRule|uniBackApiRule));
+    } else {
+        const routerMethodName = rewriteMethodToggle[(funName as reNavMethodRule)]
+        let path = (option as uniNavApiRule).url;
+        if (!path.startsWith('/')) {
+            const absolutePath = resolveAbsolutePath(path, router);
+            path = absolutePath;
+            (option as uniNavApiRule).url = absolutePath;
+        }
+        if (funName === 'switchTab') {
+            const route = routesForMapRoute(router, path, ['pathMap', 'finallyPathList'])
+            const {finallyPath} = getRoutePath(route, router);
+            if (getDataType<string | string[]>(finallyPath) === '[object Array]') {
+                warn(
+                    `uni-app 原生方法跳转路径为：${path}。此路为是tab页面时，不允许设置 alias 为数组的情况，并且不能为动态路由！当然你可以通过通配符*解决！`,
+                    router
+                );
+            }
+            if ((finallyPath as string) === '*') {
+                warn(
+                    `uni-app 原生方法跳转路径为：${path}。在路由表中找不到相关路由表！当然你可以通过通配符*解决！`,
+                    router
+                );
+            }
+            // Fixe h5 端无法触发 onTabItemTap hook  2021年6月3日17:26:47
+            if (router.options.platform === 'h5') {
+                const {success: userSuccess} = option as uniNavApiRule;
+                (option as uniNavApiRule).success = (...args:Array<any>) => {
+                    userSuccess?.apply(null, args);
+                    timeOut(150).then(() => {
+                        const cbArgs = (option as uniNavApiRule).detail || {};
+                        if (Object.keys(cbArgs).length > 0 && Reflect.has(cbArgs, 'index')) {
+                            const cachePage = getUniCachePage(0);
+                            if (Object.keys(cachePage).length === 0) {
+                                return false
+                            }
+                            const page = cachePage as objectAny;
+                            const hooks = page.$options.onTabItemTap;
+                            if (hooks) {
+                                for (let j = 0; j < hooks.length; j++) {
+                                    hooks[j].call(page, cbArgs)
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+            path = (finallyPath as string);
+        }
+        const {events, success, fail, complete, animationType, animationDuration} = option as uniNavApiRule;
+        const jumpOptions:totalNextRoute = {path, events, success, fail, complete, animationDuration, animationType};
+        router[routerMethodName](
+            notDeepClearNull<totalNextRoute>(jumpOptions)
+        )
+    }
+}

node_modules/uni-simple-router/src/public/router.ts

@@ -0,0 +1,136 @@
+import {PromiseResolve, Router, uniBackApiRule, uniBackRule} from '../options/base';
+import {InstantiateConfig, LifeCycleConfig} from '../options/config';
+import { lifeCycle, proxyHookDeps} from '../helpers/config';
+import {assertNewOptions, def, getDataType} from '../helpers/utils';
+import {registerRouterHooks, registerEachHooks} from '../helpers/lifeCycle';
+import {initMixins} from '../helpers/mixins'
+import {lockNavjump, forceGuardEach, createRoute} from '../public/methods'
+import {rewriteMethod} from '../public/rewrite'
+
+let AppReadyResolve:PromiseResolve = () => {};
+const AppReady:Promise<void> = new Promise(resolve => (AppReadyResolve = resolve));
+
+function createRouter(
+    params: InstantiateConfig
+):Router {
+    const options = assertNewOptions<InstantiateConfig>(params);
+    const router:Router = {
+        options,
+        mount: [],
+        runId: 0,
+        Vue: null,
+        proxyHookDeps: proxyHookDeps,
+        appMain: {},
+        enterPath: '',
+        $route: null,
+        $lockStatus: false,
+        routesMap: {},
+        lifeCycle: registerRouterHooks<LifeCycleConfig>(lifeCycle, options),
+        push(to) {
+            lockNavjump(to, router, 'push');
+        },
+        replace(to) {
+            lockNavjump(to, router, 'replace');
+        },
+        replaceAll(to) {
+            lockNavjump(to, router, 'replaceAll');
+        },
+        pushTab(to) {
+            lockNavjump(to, router, 'pushTab');
+        },
+        back(level = 1, animation) {
+            if (getDataType(animation) !== '[object Object]') {
+                const backRule:uniBackRule = {
+                    from: 'navigateBack'
+                }
+                animation = backRule;
+            } else {
+                if (!Reflect.has((animation as uniBackRule | uniBackApiRule), 'from')) {
+                    animation = {
+                        ...animation,
+                        from: 'navigateBack'
+                    };
+                }
+            }
+            lockNavjump(level + '', router, 'back', undefined, animation)
+        },
+        forceGuardEach(navType, forceNav) {
+            forceGuardEach(router, navType, forceNav)
+        },
+        beforeEach(userGuard):void {
+            registerEachHooks(router, 'beforeHooks', userGuard);
+        },
+        afterEach(userGuard):void {
+            registerEachHooks(router, 'afterHooks', userGuard);
+        },
+        install(Vue:any):void{
+            router.Vue = Vue;
+            rewriteMethod(this);
+            initMixins(Vue, this);
+            Object.defineProperty(Vue.prototype, '$Router', {
+                get() {
+                    const actualData = router;
+
+                    Object.defineProperty(this, '$Router', {
+                        value: actualData,
+                        writable: false,
+                        configurable: false,
+                        enumerable: false
+                    });
+
+                    return Object.seal(actualData);
+                }
+            });
+            Object.defineProperty(Vue.prototype, '$Route', {
+                get() {
+                    return createRoute(router);
+                }
+            });
+            // 【Fixe】  https://github.com/SilurianYang/uni-simple-router/issues/254
+            Object.defineProperty(Vue.prototype, '$AppReady', {
+                get() {
+                    if (router.options.platform === 'h5') {
+                        return Promise.resolve();
+                    }
+                    return AppReady;
+                },
+                set(value:boolean) {
+                    if (value === true) {
+                        AppReadyResolve();
+                    }
+                }
+            });
+        }
+    }
+    def(router, 'currentRoute', () => createRoute(router));
+
+    router.beforeEach((to, from, next) => next());
+    router.afterEach(() => {});
+    return router;
+}
+
+function RouterMount(
+    Vim:any,
+    router:Router,
+    el:string | undefined = '#app'
+) :void|never {
+    if (getDataType<Array<any>>(router.mount) === '[object Array]') {
+        router.mount.push({
+            app: Vim,
+            el
+        })
+    } else {
+        throw new Error(`挂载路由失败，router.app 应该为数组类型。当前类型：${typeof router.mount}`);
+    }
+    if (router.options.platform === 'h5') {
+        const vueRouter = (router.$route as any);
+        vueRouter.replace({
+            path: vueRouter.currentRoute.fullPath
+        });
+    } // 其他端目前不需要做啥
+}
+
+export {
+    RouterMount,
+    createRouter
+}

node_modules/uni-simple-router/src/public/uniOrigin.ts

@@ -0,0 +1,112 @@
+import { originMixins, reNavMethodRule, reNotNavMethodRule, Router, startAnimationRule, uniNavApiRule } from '../options/base';
+import { stringifyQuery } from './query';
+import {notDeepClearNull, timeOut} from '../helpers/utils'
+import { mpPlatformReg } from '../helpers/config';
+import { resetAndCallPageHook, resetPageHook } from './page';
+
+let routerNavCount:number = 0;
+let lastNavType:reNavMethodRule|reNotNavMethodRule = 'reLaunch'
+
+export function uniOriginJump(
+    router:Router,
+    originMethod:Function,
+    funName:reNavMethodRule|reNotNavMethodRule,
+    options: originMixins,
+    callOkCb?:Function,
+    forceNav?:boolean
+):void {
+    const {complete, ...originRule} = formatOriginURLQuery(router, options, funName);
+    const platform = router.options.platform;
+    if (forceNav != null && forceNav === false) {
+        if (routerNavCount === 0) {
+            routerNavCount++
+            if (platform !== 'h5') {
+                resetAndCallPageHook(router, originRule.url) // 还原及执行app.vue及首页下已经重写后的生命周期
+                // 【Fixe】  https://github.com/SilurianYang/uni-simple-router/issues/254
+                // 在小程序端  next 直接放行会执行这个
+                router.Vue.prototype.$AppReady = true;
+            }
+        }
+        complete && complete.apply(null, {msg: 'forceGuardEach强制触发并且不执行跳转'});
+        callOkCb && callOkCb.apply(null, {msg: 'forceGuardEach强制触发并且不执行跳转'})
+    } else {
+        if (routerNavCount === 0) {
+            if (platform === 'app-plus') {
+                resetAndCallPageHook(router, originRule.url) // 还原及执行app.vue下已经重写后的生命周期
+            } else {
+                if (new RegExp(mpPlatformReg, 'g').test(platform)) {
+                    // 其他就是在小程序下，首次启动发生跳转会走这里
+                    // 我们先将app.vue的生命周期执行
+                    resetAndCallPageHook(router, originRule.url, false)
+                }
+            }
+        }
+        originMethod({
+            ...originRule,
+            from: options.BACKTYPE,
+            complete: async function(...args:Array<any>) {
+                if (routerNavCount === 0) {
+                    routerNavCount++
+
+                    if (platform !== 'h5') {
+                        if (new RegExp(mpPlatformReg, 'g').test(platform)) { // 跳转完成后小程序下还原生命周期
+                            resetPageHook(router);
+                        }
+                        // 【Fixe】  https://github.com/SilurianYang/uni-simple-router/issues/254
+                        // 在小程序端 第一次 next 做跳转  会触发这个 、在app端首次必定会触发这个
+                        router.Vue.prototype.$AppReady = true;
+
+                        if (platform === 'app-plus') {
+                            const waitPage = plus.nativeObj.View.getViewById('router-loadding');
+                            waitPage && waitPage.close();
+                            const launchedHook = router.options.APP?.launchedHook;
+                            launchedHook && launchedHook();
+                        }
+                    }
+                }
+                let time:number = 0;
+                if (new RegExp(mpPlatformReg, 'g').test(platform)) {
+                    time = (router.options.applet?.animationDuration) as number
+                } else if (platform === 'app-plus') {
+                    if (funName === 'navigateBack' && lastNavType === 'navigateTo') {
+                        time = (router.options.APP?.animation?.animationDuration) as number
+                    }
+                }
+                if (funName === 'navigateTo' || funName === 'navigateBack') {
+                    if (time !== 0) {
+                        await timeOut(time);
+                    }
+                }
+                lastNavType = funName;
+                complete && complete.apply(null, args);
+                callOkCb && callOkCb.apply(null, args)
+            }
+        });
+    }
+}
+export function formatOriginURLQuery(
+    router:Router,
+    options:uniNavApiRule,
+    funName:reNavMethodRule|reNotNavMethodRule
+):uniNavApiRule {
+    const {url, path, query, animationType, animationDuration, events, success, fail, complete, delta, animation} = options;
+    const strQuery = stringifyQuery(query || {});
+    const queryURL = strQuery === '' ? (path || url) : (path || url) + strQuery;
+    let animationRule:startAnimationRule = {};
+    if (router.options.platform === 'app-plus') {
+        if (funName !== 'navigateBack') {
+            animationRule = router.options.APP?.animation || {};
+            animationRule = {...animationRule, ...animation || {}};
+        }
+    }
+    return notDeepClearNull<uniNavApiRule>({
+        delta,
+        url: queryURL,
+        animationType: animationType || animationRule.animationType,
+        animationDuration: animationDuration || animationRule.animationDuration,
+        events,
+        success,
+        fail,
+        complete
+    })
+}