@esmx/router 3.0.0-rc.18 → 3.0.0-rc.19

package/dist/history/html.mjs

@@ -1,183 +0,0 @@
-import {
-  computeScrollPosition,
-  getKeepScrollPosition,
-  getSavedScrollPosition,
-  isPathWithProtocolOrDomain,
-  normalizeLocation,
-  openWindow,
-  saveScrollPosition,
-  scrollToPosition
-} from "../utils/index.mjs";
-import { BaseRouterHistory } from "./base.mjs";
-export class HtmlHistory extends BaseRouterHistory {
-  constructor(router) {
-    super(router);
-    if ("scrollRestoration" in window.history) {
-      window.history.scrollRestoration = "manual";
-    }
-  }
-  // 获取当前地址，包括 path query hash
-  getCurrentLocation() {
-    const { href } = window.location;
-    const { state } = window.history;
-    const { path, base, ...rest } = normalizeLocation(
-      href,
-      this.router.base
-    );
-    return {
-      path: path.replace(new RegExp(`^(${base})`), ""),
-      base,
-      ...rest,
-      state
-    };
-  }
-  onPopState = (e) => {
-    if (this.isFrozen) return;
-    if (this.router.checkLayerState(e.state)) return;
-    const current = Object.assign({}, this.current);
-    this.transitionTo(this.getCurrentLocation(), async (route) => {
-      const { state } = window.history;
-      saveScrollPosition(current.fullPath, computeScrollPosition());
-      setTimeout(async () => {
-        const keepScrollPosition = state.keepScrollPosition;
-        if (keepScrollPosition) {
-          return;
-        }
-        const savedPosition = getSavedScrollPosition(route.fullPath);
-        const position = await this.router.scrollBehavior(
-          current,
-          route,
-          savedPosition
-        );
-        const { nextTick } = this.router.options;
-        if (position) {
-          nextTick && await nextTick();
-          scrollToPosition(position);
-        }
-      });
-    });
-  };
-  async init({ replace } = { replace: true }) {
-    const { initUrl } = this.router.options;
-    let route = this.getCurrentLocation();
-    if (initUrl !== void 0) {
-      route = this.resolve(initUrl);
-    } else {
-      const state = history.state || {};
-      route.state = {
-        ...state,
-        _ancientRoute: state._ancientRoute ?? true
-        // 最古历史的标记, 在调用返回事件时如果有这个标记则直接调用没有历史记录的钩子
-      };
-    }
-    if (replace) {
-      await this.replace(route);
-    } else {
-      await this.push(route);
-    }
-    this.setupListeners();
-  }
-  // 设置监听函数
-  setupListeners() {
-    window.addEventListener("popstate", this.onPopState);
-  }
-  destroy() {
-    window.removeEventListener("popstate", this.onPopState);
-  }
-  pushWindow(location) {
-    if (this.isFrozen) return;
-    this.handleOutside(location, false, true);
-  }
-  replaceWindow(location) {
-    if (this.isFrozen) return;
-    this.handleOutside(location, true, true);
-  }
-  // 处理外站跳转逻辑
-  handleOutside(location, replace = false, isTriggerWithWindow = false) {
-    const base = this.router.base;
-    const { flag, route } = isPathWithProtocolOrDomain(location, base);
-    const router = this.router;
-    const { handleOutside, validateOutside } = router.options;
-    const isSameHost = !flag || window.location.hostname === route.hostname;
-    if (!isTriggerWithWindow) {
-      if (isSameHost && !(validateOutside == null ? void 0 : validateOutside({ router, location, route }))) {
-        return false;
-      }
-    }
-    const res = handleOutside == null ? void 0 : handleOutside({
-      router,
-      route,
-      replace,
-      isTriggerWithWindow,
-      isSameHost
-    });
-    if (res === false) {
-      return true;
-    }
-    if (replace) {
-      window.location.replace(route.href);
-    } else {
-      const { hostname, href } = route;
-      openWindow(href, hostname);
-    }
-    return true;
-  }
-  // 新增路由记录跳转
-  async push(location) {
-    await this.jump(location, false);
-  }
-  // 替换当前路由记录跳转
-  async replace(location) {
-    await this.jump(location, true);
-  }
-  // 跳转方法
-  async jump(location, replace = false) {
-    if (this.isFrozen) return;
-    if (this.handleOutside(location, replace)) {
-      return;
-    }
-    const current = Object.assign({}, this.current);
-    await this.transitionTo(location, (route) => {
-      const keepScrollPosition = getKeepScrollPosition(location);
-      if (!keepScrollPosition) {
-        saveScrollPosition(current.fullPath, computeScrollPosition());
-        scrollToPosition({ left: 0, top: 0 });
-      }
-      const state = Object.assign(
-        replace ? { ...history.state, ...route.state } : { ...route.state, _ancientRoute: false },
-        { keepScrollPosition }
-      );
-      window.history[replace ? "replaceState" : "pushState"](
-        state,
-        "",
-        route.fullPath
-      );
-      this.router.updateLayerState(route);
-    });
-  }
-  go(delta) {
-    if (this.isFrozen) return;
-    window.history.go(delta);
-  }
-  forward() {
-    if (this.isFrozen) return;
-    window.history.forward();
-  }
-  timer = null;
-  back() {
-    if (this.isFrozen) return;
-    const oldState = history.state;
-    const noBackNavigation = this.router.options.noBackNavigation;
-    if (oldState._ancientRoute === true) {
-      noBackNavigation && noBackNavigation(this.router);
-      return;
-    }
-    window.history.back();
-    this.timer = setTimeout(() => {
-      if (history.state === oldState) {
-        noBackNavigation && noBackNavigation(this.router);
-      }
-      this.timer = null;
-    }, 80);
-  }
-}

package/dist/history/index.d.ts

@@ -1,7 +0,0 @@
-import { type RouterInstance, RouterMode } from '../types';
-import { AbstractHistory } from './abstract';
-import { HtmlHistory } from './html';
-export declare function createHistory({ router, mode }: {
-    router: RouterInstance;
-    mode: RouterMode;
-}): AbstractHistory | HtmlHistory;

package/dist/history/index.mjs

@@ -1,16 +0,0 @@
-import { RouterMode } from "../types/index.mjs";
-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/matcher/create-matcher.d.ts

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

package/dist/matcher/create-matcher.mjs

@@ -1,218 +0,0 @@
-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: Array.isArray(route.path) ? route.path : [route.path]
-        },
-        parent
-      )
-    );
-  }
-  return routeMatches;
-}
-function createRouteMatch(route, parent) {
-  const pathList = Array.isArray(route.path) ? 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 Array.isArray(route.path) ? routeMatches : routeMatches[routeMatches.length - 1];
-}

package/dist/matcher/index.d.ts

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

package/dist/matcher/index.mjs

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

package/dist/task-pipe/index.d.ts

@@ -1 +0,0 @@
-export { Tasks, createTasks } from './task';

package/dist/task-pipe/index.mjs

@@ -1 +0,0 @@
-export { Tasks, createTasks } from "./task.mjs";

package/dist/task-pipe/task.d.ts

@@ -1,30 +0,0 @@
-import type { Awaitable } from '../types';
-/**
- * 创建可操作的任务队列
- */
-type func = (...args: any) => any;
-/**
- * 任务状态
- */
-export declare enum TaskStatus {
-    INITIAL = "initial",
-    RUNNING = "running",
-    FINISHED = "finished",
-    ERROR = "error",
-    ABORTED = "aborted"
-}
-export declare class Tasks<T extends func = func> {
-    protected handlers: T[];
-    add(handler: T | T[]): void;
-    reset(): void;
-    get list(): T[];
-    get length(): number;
-    status: TaskStatus;
-    run({ cb, final }?: {
-        cb?: (res: Awaited<ReturnType<T>>) => Awaitable<void>;
-        final?: () => Awaitable<void>;
-    }): Promise<void>;
-    abort(): void;
-}
-export declare function createTasks<T extends func = func>(): Tasks<T>;
-export {};

package/dist/task-pipe/task.mjs

@@ -1,66 +0,0 @@
-import { warn } from "../utils/index.mjs";
-export var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
-  TaskStatus2["INITIAL"] = "initial";
-  TaskStatus2["RUNNING"] = "running";
-  TaskStatus2["FINISHED"] = "finished";
-  TaskStatus2["ERROR"] = "error";
-  TaskStatus2["ABORTED"] = "aborted";
-  return TaskStatus2;
-})(TaskStatus || {});
-export class Tasks {
-  handlers = [];
-  add(handler) {
-    const params = Array.isArray(handler) ? handler : [handler];
-    this.handlers.push(...params);
-  }
-  reset() {
-    this.handlers = [];
-  }
-  get list() {
-    return this.handlers;
-  }
-  get length() {
-    return this.handlers.length;
-  }
-  status = "initial" /* INITIAL */;
-  async run({
-    cb,
-    final
-  } = {}) {
-    if (this.status !== "initial") {
-      if (process.env.NODE_ENV !== "production") {
-        warn(`task start failed in status ${this.status}`);
-      }
-      return;
-    }
-    this.status = "running" /* RUNNING */;
-    for await (const handler of this.list) {
-      if (this.status === "aborted" /* ABORTED */) {
-        return;
-      }
-      if (typeof handler === "function") {
-        try {
-          const res = await handler();
-          cb && await cb(res);
-        } catch (error) {
-          warn("task error:", error);
-          this.status = "error" /* ERROR */;
-        }
-      } else {
-        warn("task is not a function", handler);
-      }
-    }
-    if (this.status !== "running" /* RUNNING */) return;
-    final && await final();
-    this.status = "finished" /* FINISHED */;
-  }
-  abort() {
-    if (process.env.NODE_ENV !== "production" && this.status === "running" /* RUNNING */) {
-      warn("abort task when task is running");
-    }
-    this.status = "aborted" /* ABORTED */;
-  }
-}
-export function createTasks() {
-  return new Tasks();
-}