@esmx/router 3.0.0-rc.12

package/dist/history/index.mjs

@@ -0,0 +1,16 @@
+import { RouterMode } from "../types";
+import { AbstractHistory } from "./abstract.mjs";
+import { HtmlHistory } from "./html.mjs";
+export function createHistory({
+  router,
+  mode
+}) {
+  switch (mode) {
+    case RouterMode.HISTORY:
+      return new HtmlHistory(router);
+    case RouterMode.ABSTRACT:
+      return new AbstractHistory(router);
+    default:
+      throw new Error("not support mode");
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createRouter } from './router';
+export * from './types';
+export * from './utils';

package/dist/index.mjs

@@ -0,0 +1,3 @@
+export { createRouter } from "./router.mjs";
+export * from "./types";
+export * from "./utils/index.mjs";

package/dist/matcher/create-matcher.d.ts

@@ -0,0 +1,5 @@
+import type { RouteConfig, RouterMatcher } from '../types';
+/**
+ * 创建路由匹配器
+ */
+export declare function createRouterMatcher(routes: RouteConfig[]): RouterMatcher;

package/dist/matcher/create-matcher.mjs

@@ -0,0 +1,218 @@
+import { compile, match, pathToRegexp } from "path-to-regexp";
+import {
+  decode,
+  encodePath,
+  normalizeLocation,
+  normalizePath,
+  parsePath,
+  stringifyPath
+} from "../utils/index.mjs";
+class RouteMatcher {
+  /*
+   * 路由匹配规则
+   */
+  routeMatches;
+  /*
+   * 原始路由配置
+   */
+  // protected routes: RouteConfig[];
+  constructor(routes) {
+    this.routeMatches = createRouteMatches(routes);
+  }
+  /*
+   * 根据配置匹配对应的路由
+   */
+  match(rawLocation, {
+    base,
+    redirectedFrom
+  } = { base: "" }) {
+    let path = "";
+    let query = {};
+    let queryArray = {};
+    let params = {};
+    let hash = "";
+    let state = {};
+    const parsedOption = parsePath(rawLocation.path);
+    path = parsedOption.pathname;
+    query = rawLocation.query || parsedOption.query || {};
+    queryArray = rawLocation.queryArray || parsedOption.queryArray || {};
+    hash = rawLocation.hash || parsedOption.hash || "";
+    state = rawLocation.state || {};
+    const routeMatch = this.routeMatches.find(({ match: match2 }) => {
+      return match2(path);
+    });
+    if (routeMatch) {
+      const {
+        component,
+        asyncComponent,
+        compile: compile2,
+        meta,
+        redirect,
+        matched,
+        parse
+      } = routeMatch.internalRedirect || routeMatch;
+      params = rawLocation.params || parse(path).params || {};
+      const realPath = normalizePath(
+        compile2({
+          query,
+          queryArray,
+          params,
+          hash
+        })
+      );
+      const {
+        params: realParams,
+        query: realQuery,
+        queryArray: realQueryArray,
+        hash: realHash
+      } = parse(realPath);
+      const routeRecord = {
+        base,
+        path: normalizePath(
+          compile2({
+            params: realParams
+          })
+        ),
+        fullPath: realPath,
+        params: realParams,
+        query: realQuery,
+        queryArray: realQueryArray,
+        hash: realHash,
+        state,
+        component,
+        asyncComponent,
+        meta,
+        redirect,
+        redirectedFrom,
+        matched
+      };
+      if (redirect) {
+        const normalizedLocation = normalizeLocation(
+          typeof redirect === "function" ? redirect(routeRecord) : redirect,
+          base
+        );
+        return this.match(normalizedLocation, {
+          base,
+          redirectedFrom: routeRecord
+        });
+      }
+      return routeRecord;
+    }
+    return null;
+  }
+  /*
+   * 获取当前路由匹配规则
+   */
+  getRoutes() {
+    return this.routeMatches;
+  }
+  /**
+   * 新增单个路由匹配规则
+   */
+  // public addRoute(route: RouteConfig) {
+  //     this.routes.push(route);
+  //     this.routeMatches = createRouteMatches(this.routes);
+  // }
+  /**
+   * 新增多个路由匹配规则
+   */
+  // public addRoutes(routes: RouteConfig[]) {
+  //     this.routes.push(...routes);
+  //     this.routeMatches = createRouteMatches(this.routes);
+  // }
+}
+export function createRouterMatcher(routes) {
+  return new RouteMatcher(routes);
+}
+function createRouteMatches(routes, parent) {
+  const routeMatches = [];
+  for (const route of routes) {
+    routeMatches.push(
+      ...createRouteMatch(
+        {
+          ...route,
+          path: route.path instanceof Array ? route.path : [route.path]
+        },
+        parent
+      )
+    );
+  }
+  return routeMatches;
+}
+function createRouteMatch(route, parent) {
+  const pathList = route.path instanceof Array ? route.path : [route.path];
+  const routeMatches = pathList.reduce(
+    (acc, item, index) => {
+      const { children } = route;
+      const path = normalizePath(item, parent == null ? void 0 : parent.path);
+      let regex;
+      try {
+        regex = pathToRegexp(path);
+      } catch (error) {
+        console.warn(
+          `@create route rule failed on path: ${path}`,
+          route
+        );
+        return acc;
+      }
+      const toPath = compile(path, { encode: encodePath });
+      const parseParams = match(path, { decode });
+      const current = {
+        regex,
+        match: (path2) => {
+          return regex.test(path2);
+        },
+        parse: (path2) => {
+          const { pathname, query, queryArray, hash } = parsePath(path2);
+          const { params } = parseParams(pathname) || { params: {} };
+          return {
+            params: Object.assign({}, params),
+            // parse的 params 是使用 Object.create(null) 创建的没有原型的对象，需要进行包装处理
+            query,
+            queryArray,
+            hash
+          };
+        },
+        compile: ({ params = {}, query = {}, queryArray = {}, hash = "" } = {
+          params: {},
+          query: {},
+          queryArray: {},
+          hash: ""
+        }) => {
+          const pathString = toPath(params);
+          return stringifyPath({
+            pathname: pathString,
+            query,
+            queryArray,
+            hash
+          });
+        },
+        path,
+        appType: route.appType || (parent == null ? void 0 : parent.appType) || "",
+        component: route.component,
+        asyncComponent: route.asyncComponent,
+        meta: route.meta || {},
+        redirect: route.redirect,
+        /**
+         * 第一个 path 作为基准，后续 path 会内部重定向到第一个 path
+         * 同时如果父路由存在内部跳转，子路由也需要处理内部跳转
+         */
+        internalRedirect: index > 0 || (parent == null ? void 0 : parent.internalRedirect) ? createRouteMatch(
+          {
+            ...route,
+            path: pathList[0]
+          },
+          (parent == null ? void 0 : parent.internalRedirect) || parent
+        ) : void 0,
+        matched: [...(parent == null ? void 0 : parent.matched) || [], route]
+      };
+      if (children && children.length > 0) {
+        acc.push(...createRouteMatches(children, current));
+      }
+      acc.push(current);
+      return acc;
+    },
+    []
+  );
+  return route.path instanceof Array ? routeMatches : routeMatches[routeMatches.length - 1];
+}

package/dist/matcher/create-matcher.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/matcher/index.d.ts

@@ -0,0 +1 @@
+export { createRouterMatcher } from './create-matcher';

package/dist/matcher/index.mjs

@@ -0,0 +1 @@
+export { createRouterMatcher } from "./create-matcher.mjs";

package/dist/router.d.ts

@@ -0,0 +1,111 @@
+import { type HistoryState, type NavigationGuard, type NavigationGuardAfter, type RegisteredConfig, type RegisteredConfigMap, type Route, type RouteRecord, type RouterBase, type RouterHistory, type RouterInitOptions, type RouterInstance, type RouterMatcher, RouterMode, type RouterOptions, type RouterRawLocation, type RouterScrollBehavior } from './types';
+/**
+ * 路由类
+ */
+export declare class Router implements RouterInstance {
+    /**
+     * 当前路由对象的上级路由对象
+     */
+    parent: RouterInstance | null;
+    options: RouterOptions;
+    /**
+     * 路由固定前置路径
+     * 需要注意的是如果使用函数返回 base，需要尽量保证相同的路径返回相同base
+     */
+    base: RouterBase;
+    mode: RouterMode;
+    matcher: RouterMatcher;
+    history: RouterHistory;
+    scrollBehavior: RouterScrollBehavior;
+    route: Route;
+    constructor(options: RouterOptions);
+    updateRoute(route: RouteRecord): void;
+    protected applyRoute(route: RouteRecord): void;
+    resolve(location: RouterRawLocation): RouteRecord;
+    /**
+     * 新增单个路由匹配规则
+     */
+    /**
+     * 新增多个路由匹配规则
+     */
+    init(options?: RouterInitOptions): Promise<void>;
+    /**
+     * 卸载方法
+     */
+    destroy(): Promise<void>;
+    registeredConfigMap: RegisteredConfigMap;
+    register(name: string, config: (router: RouterInstance) => RegisteredConfig): void;
+    readonly guards: {
+        beforeEach: NavigationGuard[];
+        afterEach: NavigationGuardAfter[];
+    };
+    beforeEach(guard: NavigationGuard): void;
+    unBindBeforeEach(guard: NavigationGuard): void;
+    afterEach(guard: NavigationGuardAfter): void;
+    unBindAfterEach(guard: NavigationGuardAfter): void;
+    push(location: RouterRawLocation): Promise<void>;
+    replace(location: RouterRawLocation): Promise<void>;
+    /**
+     * 当前路由弹层id，用于区分不同的路由弹层
+     */
+    layerId: number;
+    /**
+     * 路由弹层配置
+     * key为路由弹层id
+     */
+    layerConfigList: Array<{
+        /**
+         * 路由弹层id
+         */
+        id: number;
+        /**
+         * 路由弹层深度
+         */
+        depth: number;
+    }>;
+    /**
+     * 路由弹层id与路由实例的map
+     */
+    layerMap: Record<number, {
+        router: RouterInstance;
+        config: RegisteredConfig;
+        destroyed: boolean;
+    }>;
+    /**
+     * 路由是否冻结
+     */
+    isFrozen: boolean;
+    /**
+     * 路由冻结方法
+     */
+    freeze(): void;
+    /**
+     * 路由解冻方法
+     */
+    unfreeze(): void;
+    /**
+     * 打开路由弹层方法，会创建新的路由实例并调用注册的 register 方法
+     * 服务端会使用 push 作为替代
+     */
+    pushLayer(location: RouterRawLocation): Promise<void>;
+    /**
+     * 更新路由弹层方法
+     * @param state 参数为history.state
+     * @description 没有传入 state 时使用当前配置更新 history.state，传入了 state 时使用传入的 state 更新当前配置
+     */
+    checkLayerState(state: HistoryState): boolean;
+    updateLayerState(route: RouteRecord): void;
+    /**
+     * 新开浏览器窗口的方法，在服务端会调用 push 作为替代
+     */
+    pushWindow(location: RouterRawLocation): void;
+    /**
+     * 替换当前浏览器窗口的方法，在服务端会调用 replace 作为替代
+     */
+    replaceWindow(location: RouterRawLocation): void;
+    go(delta?: number): void;
+    forward(): void;
+    back(): void;
+    getRoutes(): any;
+}
+export declare function createRouter(options: RouterOptions): RouterInstance;