feat(router): 重构导航类型和结果，统一使用 NavigationType 枚举

Author: lzxb

packages/router/src/next/router.ts

@@ -1,12 +1,12 @@
 import { rawLocationToURL } from './location';
 import { type RouteMatchFunc, createMatcher } from './matcher';
 import { createRoute } from './route';
-import type {
-    Route,
-    RouteInput,
-    RouteResult,
-    RouterOptions,
-    RouterRawLocation
+import {
+    type Navigation,
+    type NavigationResult,
+    NavigationType,
+    type RouterOptions,
+    type RouterRawLocation
 } from './types';
 
 export class Router {
@@ -16,22 +16,8 @@ export class Router {
         this.options = options;
         this.matcher = createMatcher(options.routes);
     }
-    private _update(input: RouteInput): Promise<RouteResult> {
-        // switch (input.type) {
-        //     case 'push':
-        //         break;
-        //     // case 'pushLayer':
-        //     //     const result = await XXX('')
-        //     //     if (XXXX) {
-        //     //         return this._update({})
-        //     //     }
-        //     case 'reload':
-        //         //  1、销毁实例，再创建实例
-        //         //  2. replace('sss') ->
-        //         break;
-        // }
-    }
-    public async parseRoute(raw: RouterRawLocation): Promise<RouteResult> {
+    private _update(input: Navigation): Promise<NavigationResult> {}
+    public async parseRoute(raw: RouterRawLocation): Promise<NavigationResult> {
         const { base, normalizeURL, externalUrlHandler } = this.options;
         let location = rawLocationToURL(raw, base);
         if (normalizeURL) {
@@ -41,15 +27,15 @@ export class Router {
         if (location.origin !== base.origin) {
             externalUrlHandler?.(location);
             return {
-                type: 'external'
+                type: NavigationType.external
             };
         }
         // 匹配路由
         const matched = this.matcher(location, base);
         // 没有匹配任何路由
         if (matched.matches.length === 0) {
             return {
-                type: 'notFound'
+                type: NavigationType.notFound
             };
         }
         // 重新构造 URL 参数
@@ -67,54 +53,53 @@ export class Router {
             Object.assign(matched.params, raw.params);
         }
         const route = createRoute(raw, location, base, matched);
-        console.log('route', route);
     }
     public push(location: RouterRawLocation) {
         return this._update({
-            type: 'push',
+            type: NavigationType.push,
             location
         });
     }
     public replace(options: RouterRawLocation) {
         return this._update({
-            type: 'replace',
+            type: NavigationType.replace,
             location
         });
     }
     public go(index: number) {
         return this._update({
-            type: 'go',
+            type: NavigationType.go,
             index
         });
     }
     public forward() {
         return this._update({
-            type: 'forward'
+            type: NavigationType.forward
         });
     }
     public back() {
         return this._update({
-            type: 'back'
+            type: NavigationType.back
         });
     }
     public pushLayer() {
         return this._update({
-            type: 'pushLayer'
+            type: NavigationType.pushLayer
         });
     }
     public openWindow() {
         return this._update({
-            type: 'openWindow'
+            type: NavigationType.openWindow
         });
     }
     public reload() {
         return this._update({
-            type: 'reload'
+            type: NavigationType.reload
         });
     }
     public forceReload() {
         return this._update({
-            type: 'forceReload'
+            type: NavigationType.forceReload
         });
     }
 }

packages/router/src/next/types.ts

@@ -1,86 +1,99 @@
-// 路由输入
+export enum NavigationType {
+    push = 'push',
+    replace = 'replace',
+    go = 'go',
+    forward = 'forward',
+    back = 'back',
+    pushLayer = 'pushLayer',
+    openWindow = 'openWindow',
+    reload = 'reload',
+    forceReload = 'forceReload',
+    // 导航结果类型
+    aborted = 'aborted',
+    redirect = 'redirect',
+    external = 'external',
+    notFound = 'notFound'
+}
 
-export interface RouteInputPush {
-    type: 'push';
+export interface NavigationPush {
+    type: NavigationType.push;
     location: RouterRawLocation;
 }
-export interface RouteInputReplace {
-    type: 'replace';
+export interface NavigationReplace {
+    type: NavigationType.replace;
     location: RouterRawLocation;
 }
-export interface RouteInputGo {
-    type: 'go';
+export interface NavigationGo {
+    type: NavigationType.go;
     index: number;
 }
 
-export interface RouteInputForward {
-    type: 'forward';
+export interface NavigationForward {
+    type: NavigationType.forward;
 }
-export interface RouteInputBack {
-    type: 'back';
+export interface NavigationBack {
+    type: NavigationType.back;
 }
 
-export interface RouteInputPushLayer {
-    type: 'pushLayer';
+export interface NavigationPushLayer {
+    type: NavigationType.pushLayer;
 }
-export interface RouteInputOpenWindow {
-    type: 'openWindow';
+export interface NavigationOpenWindow {
+    type: NavigationType.openWindow;
     name?: string;
     windowFeatures?: string;
 }
 
-export interface RouteInputReload {
-    type: 'reload';
+export interface NavigationReload {
+    type: NavigationType.reload;
     location?: RouterRawLocation;
 }
 
-export interface RouteInputForceReload {
-    type: 'forceReload';
+export interface NavigationForceReload {
+    type: NavigationType.forceReload;
     url?: string;
 }
 
-export type RouteInput =
-    | RouteInputPush
-    | RouteInputReplace
-    | RouteInputGo
-    | RouteInputForward
-    | RouteInputBack
-    | RouteInputPushLayer
-    | RouteInputOpenWindow
-    | RouteInputReload
-    | RouteInputForceReload;
-
-// 路由输出
-
-export interface RouteResultPush {
-    type: 'push';
+export type Navigation =
+    | NavigationPush
+    | NavigationReplace
+    | NavigationGo
+    | NavigationForward
+    | NavigationBack
+    | NavigationPushLayer
+    | NavigationOpenWindow
+    | NavigationReload
+    | NavigationForceReload;
+
+export interface NavigationResultPush {
+    type: NavigationType.push;
 }
-export interface RouteResultReplace {
-    type: 'replace';
+export interface NavigationResultReplace {
+    type: NavigationType.replace;
 }
-export interface RouteResultAborted {
-    type: 'aborted';
+export interface NavigationResultAborted {
+    type: NavigationType.aborted;
 }
-export interface RouteResultRedirect {
-    type: 'redirect';
+export interface NavigationResultRedirect {
+    type: NavigationType.redirect;
 }
-export interface RouteResultUpdateIndex {
-    type: 'redirect';
+export interface NavigationResultUpdateIndex {
+    type: NavigationType.redirect;
 }
-export interface RouteResultExternal {
-    type: 'external';
+export interface NavigationResultExternal {
+    type: NavigationType.external;
 }
-export interface RouteResultNotFound {
-    type: 'notFound';
+export interface NavigationResultNotFound {
+    type: NavigationType.notFound;
 }
 
-export type RouteResult =
-    | RouteResultPush
-    | RouteResultReplace
-    | RouteResultAborted
-    | RouteResultRedirect
-    | RouteResultExternal
-    | RouteResultNotFound;
+export type NavigationResult =
+    | NavigationResultPush
+    | NavigationResultReplace
+    | NavigationResultAborted
+    | NavigationResultRedirect
+    | NavigationResultExternal
+    | NavigationResultNotFound;
 
 // 构造实例选项
 export interface RouterOptions {