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

package/dist/utils/index.mjs

@@ -1,27 +0,0 @@
-export {
-  regexDomain,
-  normalizePath,
-  parsePath,
-  stringifyPath,
-  normalizeLocation,
-  isPathWithProtocolOrDomain
-} from "./path.mjs";
-export { isESModule, inBrowser } from "./utils.mjs";
-export { warn } from "./warn.mjs";
-export { isSameRoute, isEqualRoute } from "./guards.mjs";
-export {
-  computeScrollPosition,
-  scrollToPosition,
-  saveScrollPosition,
-  getSavedScrollPosition,
-  getKeepScrollPosition
-} from "./scroll.mjs";
-export { openWindow } from "./bom.mjs";
-export {
-  encodeHash,
-  encodeParam,
-  encodePath,
-  encodeQueryKey,
-  encodeQueryValue,
-  decode
-} from "./encoding.mjs";

package/dist/utils/path.d.ts

@@ -1,60 +0,0 @@
-import type { Route, RouterBase, RouterLocation, RouterRawLocation } from '../types';
-/**
- * 判断路径是否以 http 或 https 开头 或者直接是域名开头
- */
-export declare const regexDomain: RegExp;
-/**
- * 判断路径是否以 scheme 协议开头
- */
-export declare const regexScheme: RegExp;
-/**
- * 判断路径是否以 http(s) 协议开头
- */
-export declare const regexHttpScheme: RegExp;
-/**
- * 格式化路径 主要用于拼接嵌套路由的路径
- * 返回的格式化后的路径如果有协议则以协议开头，如果没有协议则以/开头
- */
-export declare function normalizePath(path: string, parentPath?: string): string;
-/**
- * 路径解析方法
- * @example 输入 https://www.google.com/test1/test2?a=1&b=2#123 输出 { pathname: '/test1/test2', query: { a: '1', b: '2' }, queryArray: { a: ['1'], b: ['2'] }, hash: '123' }
- * 输入 /test1/test2?a=1&b=2#123 同样输出 { pathname: '/test1/test2', query: { a: '1', b: '2' }, queryArray: { a: ['1'], b: ['2'] }, hash: '123' }
- */
-export declare function parsePath(path?: string): {
-    pathname: string;
-    query: Record<string, string>;
-    queryArray: Record<string, string[]>;
-    hash: string;
-};
-/**
- * 将path query hash合并为完整路径
- * @example stringifyPath({ pathname: '/news', query: { a: '1' }, hash: '123' }) 输出 '/news?a=1#123'
- */
-export declare function stringifyPath({ pathname, query, queryArray, hash }?: {
-    pathname: string;
-    query: Record<string, string | undefined>;
-    queryArray: Record<string, string[]>;
-    hash: string;
-}): string;
-/**
- * 标准化 RouterLocation 字段
- */
-export declare function normalizeLocation(rawLocation: RouterRawLocation, base?: RouterBase): RouterLocation & {
-    path: string;
-    base: string;
-    queryArray: Record<string, string[]>;
-};
-/**
- * 判断路径是否以协议或域名开头
- */
-export declare function isPathWithProtocolOrDomain(location: RouterRawLocation, base?: RouterBase): {
-    /**
-     * 是否以协议或域名开头
-     */
-    flag: boolean;
-    /**
-     * 虚假的 route 信息，内部跳转时无法信任，只有外站跳转时使用
-     */
-    route: Route;
-};

package/dist/utils/path.mjs

@@ -1,281 +0,0 @@
-import normalizeUrl from "normalize-url";
-import URLParse from "url-parse";
-import {
-  decode,
-  decodeQuery,
-  encodeHash,
-  encodeQueryKey,
-  encodeQueryValue
-} from "./encoding.mjs";
-import { isValidValue } from "./utils.mjs";
-import { assert } from "./warn.mjs";
-export const regexDomain = /^(?:https?:\/\/|[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9](\/.*)?/i;
-export const regexScheme = /^(?:[a-z][a-z\d+.-]*:.+)/i;
-export const regexHttpScheme = /^(http(s)?:\/\/)/;
-function removeDuplicateSlashes(url) {
-  if (url.includes("://")) {
-    const [base, path] = url.split("://");
-    const result2 = path.replace(/\/{2,}/g, "/");
-    return `${base}://${result2}`;
-  }
-  const result = url.replace(/\/{2,}/g, "/");
-  return result;
-}
-export function normalizePath(path, parentPath) {
-  let normalizedPath = parentPath ? `${parentPath}/${path}` : `${path}`;
-  if (!regexHttpScheme.test(normalizedPath) && !normalizedPath.startsWith("/")) {
-    normalizedPath = `/${normalizedPath}`;
-  }
-  return (
-    // 只有存在父级路由才进行路由拼接
-    removeDuplicateSlashes(normalizedPath).replace(/\/$/, "") || // 移除结尾的斜杠 /
-    "/"
-  );
-}
-export function parsePath(path = "") {
-  path = normalizePath(path);
-  const { pathname, query, hash } = new URLParse(path || "/");
-  const queryObj = {};
-  const queryArray = {};
-  if (query.length > 0) {
-    query.slice(1).split("&").forEach((item) => {
-      let [key = "", value = ""] = item.split("=");
-      key = decode(key);
-      value = decodeQuery(value);
-      if (key) {
-        queryObj[key] = value;
-        queryArray[key] = (queryArray[key] || []).concat(value);
-      }
-    });
-  }
-  return {
-    pathname,
-    query: queryObj,
-    queryArray,
-    hash: decode(hash)
-  };
-}
-export function stringifyPath({
-  pathname = "",
-  query = {},
-  queryArray = {},
-  hash = ""
-} = {
-  pathname: "",
-  query: {},
-  queryArray: {},
-  hash: ""
-}) {
-  const queryString = Object.entries(
-    Object.assign({}, query, queryArray)
-  ).reduce((acc, [key, value]) => {
-    let query2 = "";
-    const encodedKey = encodeQueryKey(key);
-    if (Array.isArray(value)) {
-      query2 = value.reduce((all, item) => {
-        if (!isValidValue(item)) return all;
-        const encodedValue = encodeQueryValue(item);
-        if (encodedValue) {
-          all = all ? `${all}&${encodedKey}=${encodedValue}` : `${encodedKey}=${encodedValue}`;
-        }
-        return all;
-      }, "");
-    } else {
-      const encodedValue = encodeQueryValue(value);
-      if (isValidValue(value)) {
-        query2 = `${encodedKey}=${encodedValue}`;
-      }
-    }
-    if (query2) {
-      acc = acc ? `${acc}&${query2}` : `?${query2}`;
-    }
-    return acc;
-  }, "");
-  const hashContent = hash.startsWith("#") ? hash.replace(/^#/, "") : hash;
-  const hashString = hashContent ? `#${encodeHash(hashContent)}` : "";
-  return `${pathname}${queryString}${hashString}`;
-}
-export function normalizeLocation(rawLocation, base = "") {
-  let pathname = "";
-  let query = {};
-  let queryArray = {};
-  let hash = "";
-  let params;
-  let state = {};
-  if (typeof rawLocation === "object") {
-    const parsedOption = parsePath(rawLocation.path);
-    pathname = parsedOption.pathname;
-    if (rawLocation.query || rawLocation.queryArray) {
-      queryArray = rawLocation.queryArray || {};
-      query = rawLocation.query || {};
-    } else {
-      queryArray = parsedOption.queryArray;
-      query = parsedOption.query;
-    }
-    hash = rawLocation.hash || parsedOption.hash;
-    params = rawLocation.params;
-    state = rawLocation.state || {};
-  } else {
-    const parsedOption = parsePath(rawLocation);
-    pathname = parsedOption.pathname;
-    query = parsedOption.query;
-    queryArray = parsedOption.queryArray;
-    hash = parsedOption.hash;
-  }
-  const fullPath = stringifyPath({
-    pathname,
-    query,
-    queryArray,
-    hash
-  });
-  const baseString = normalizePath(
-    typeof base === "function" ? base({
-      fullPath,
-      query,
-      queryArray,
-      hash
-    }) : base
-  );
-  let path = pathname;
-  if (regexDomain.test(baseString)) {
-    const { pathname: pathname2 } = new URLParse(baseString);
-    path = normalizePath(path.replace(new RegExp(`^(${pathname2})`), ""));
-  }
-  path = normalizePath(path.replace(new RegExp(`^(${baseString})`), ""));
-  const { query: realQuery, queryArray: realQueryArray } = parsePath(fullPath);
-  const res = {
-    base: baseString,
-    path,
-    query: realQuery,
-    queryArray: realQueryArray,
-    hash,
-    state
-  };
-  if (params) res.params = params;
-  return res;
-}
-export function isPathWithProtocolOrDomain(location, base = "") {
-  let url = "";
-  let state = {};
-  let baseString = "";
-  if (typeof base === "string") {
-    baseString = base;
-  } else {
-    baseString = base({
-      fullPath: "",
-      query: {},
-      queryArray: {},
-      hash: ""
-    });
-  }
-  if (typeof location === "string") {
-    url = location;
-  } else {
-    state = location.state || {};
-    const {
-      path,
-      query: query2 = {},
-      queryArray: queryArray2,
-      hash: hash2 = "",
-      ...nLocation
-    } = normalizeLocation(location);
-    url = stringifyPath({
-      ...nLocation,
-      query: query2,
-      queryArray: queryArray2,
-      pathname: path,
-      hash: hash2
-    });
-  }
-  try {
-    url = normalizeUrl(url, {
-      stripWWW: false,
-      removeQueryParameters: false
-    });
-  } catch (error) {
-    try {
-      url = new URL(url, baseString).href;
-    } catch (error2) {
-      assert(false, `Invalid URL: ${url}`);
-    }
-  }
-  if (regexScheme.test(url) && !regexHttpScheme.test(url)) {
-    const {
-      hash: hash2,
-      host: host2,
-      hostname: hostname2,
-      href: href2,
-      origin: origin2,
-      pathname: pathname2,
-      port: port2,
-      protocol: protocol2,
-      search: search2
-    } = new URL(url);
-    const route2 = {
-      hash: hash2,
-      host: host2,
-      hostname: hostname2,
-      href: href2,
-      origin: origin2,
-      pathname: pathname2,
-      port: port2,
-      protocol: protocol2,
-      search: search2,
-      params: {},
-      query: {},
-      queryArray: {},
-      state,
-      meta: {},
-      path: pathname2,
-      fullPath: url,
-      base: "",
-      matched: []
-    };
-    return {
-      flag: true,
-      route: route2
-    };
-  }
-  const {
-    hash,
-    host,
-    hostname,
-    href,
-    origin,
-    pathname,
-    port,
-    protocol,
-    query: search
-  } = new URLParse(url);
-  const { query = {}, queryArray } = normalizeLocation(url);
-  const route = {
-    href,
-    origin,
-    host,
-    protocol,
-    hostname,
-    port,
-    pathname,
-    search,
-    hash,
-    query,
-    queryArray,
-    params: {},
-    state,
-    meta: {},
-    path: pathname,
-    fullPath: `${pathname}${search}${hash}`,
-    base: "",
-    matched: []
-  };
-  if (regexDomain.test(url)) {
-    return {
-      flag: true,
-      route
-    };
-  }
-  return {
-    flag: false,
-    route
-  };
-}

package/dist/utils/path.spec.mjs

@@ -1,27 +0,0 @@
-import { describe, it } from "vitest";
-import { normalizeLocation, normalizePath } from "./path.mjs";
-describe("testing normalizeLocation", () => {
-  it("testing normal domain", ({ expect }) => {
-    expect(
-      normalizeLocation(
-        "http://localhost:5173/en/en/en/en/en",
-        "http://localhost:5173/en/"
-      ).path
-    ).toBe("/en/en/en/en");
-  });
-  it("testing path", ({ expect }) => {
-    expect(
-      normalizeLocation("/test1/test2?t=https://www-six.betafollowme.com").path
-    ).toBe("/test1/test2");
-  });
-});
-describe("testing normalizePath", () => {
-  it("testing normal domain", ({ expect }) => {
-    expect(normalizePath("test2", "test1")).toBe("/test1/test2");
-  });
-  it("testing path", ({ expect }) => {
-    expect(
-      normalizeLocation("/test1/test2?t=https://www-six.betafollowme.com").path
-    ).toBe("/test1/test2");
-  });
-});

package/dist/utils/scroll.d.ts

@@ -1,25 +0,0 @@
-import type { RouterRawLocation, ScrollPosition, _ScrollPositionNormalized } from '../types';
-/**
- * 获取当前滚动位置
- */
-export declare const computeScrollPosition: () => _ScrollPositionNormalized;
-/**
- * 滚动到指定位置
- */
-export declare function scrollToPosition(position: ScrollPosition): void;
-/**
- * 存储的滚动位置
- */
-export declare const scrollPositions: Map<string, _ScrollPositionNormalized>;
-/**
- * 保存滚动位置
- */
-export declare function saveScrollPosition(key: string, scrollPosition: _ScrollPositionNormalized): void;
-/**
- * 获取存储的滚动位置
- */
-export declare function getSavedScrollPosition(key: string): _ScrollPositionNormalized | null;
-/**
- * 获取跳转配置的保持滚动位置参数
- */
-export declare function getKeepScrollPosition(location: RouterRawLocation): boolean;

package/dist/utils/scroll.mjs

@@ -1,59 +0,0 @@
-import { warn } from "./warn.mjs";
-export const computeScrollPosition = () => ({
-  left: window.scrollX,
-  top: window.scrollY
-});
-function getElementPosition(el, offset) {
-  const docRect = document.documentElement.getBoundingClientRect();
-  const elRect = el.getBoundingClientRect();
-  return {
-    behavior: offset.behavior,
-    left: elRect.left - docRect.left - (offset.left || 0),
-    top: elRect.top - docRect.top - (offset.top || 0)
-  };
-}
-export function scrollToPosition(position) {
-  let scrollToOptions;
-  if ("el" in position) {
-    const positionEl = position.el;
-    const isIdSelector = typeof positionEl === "string" && positionEl.startsWith("#");
-    const el = typeof positionEl === "string" ? isIdSelector ? document.getElementById(positionEl.slice(1)) : document.querySelector(positionEl) : positionEl;
-    if (!el) {
-      return;
-    }
-    scrollToOptions = getElementPosition(el, position);
-  } else {
-    scrollToOptions = position;
-  }
-  if ("scrollBehavior" in document.documentElement.style) {
-    window.scrollTo(scrollToOptions);
-  } else {
-    window.scrollTo(
-      scrollToOptions.left != null ? scrollToOptions.left : window.scrollX,
-      scrollToOptions.top != null ? scrollToOptions.top : window.scrollY
-    );
-  }
-}
-export const scrollPositions = /* @__PURE__ */ new Map();
-const POSITION_KEY = "__scroll_position_key";
-export function saveScrollPosition(key, scrollPosition) {
-  scrollPositions.set(key, scrollPosition);
-  const stateCopy = Object.assign({}, window.history.state);
-  stateCopy[POSITION_KEY] = scrollPosition;
-  try {
-    const protocolAndPath = window.location.protocol + "//" + window.location.host;
-    const absolutePath = window.location.href.replace(protocolAndPath, "");
-    window.history.replaceState(stateCopy, "", absolutePath);
-  } catch (error) {
-    warn(`Failed to save scroll position.`, error);
-  }
-}
-export function getSavedScrollPosition(key) {
-  const scroll = scrollPositions.get(key) || history.state[POSITION_KEY];
-  scrollPositions.delete(key);
-  return scroll || null;
-}
-export function getKeepScrollPosition(location) {
-  if (typeof location === "string") return false;
-  return location.keepScrollPosition || false;
-}

package/dist/utils/utils.d.ts

@@ -1,16 +0,0 @@
-/**
- * 是否在浏览器环境
- */
-export declare const inBrowser: boolean;
-/**
- *  Symbol 是否可用
- */
-export declare const isSymbolAble: boolean;
-/**
- * 判断是否是 es module 对象
- */
-export declare function isESModule(obj: any): boolean;
-/**
- * 判断是否是合法的值
- */
-export declare function isValidValue(value: any): boolean;

package/dist/utils/utils.mjs

@@ -1,11 +0,0 @@
-export const inBrowser = typeof window !== "undefined";
-export const isSymbolAble = typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol";
-export function isESModule(obj) {
-  return Boolean(obj.__esModule) || isSymbolAble && obj[Symbol.toStringTag] === "Module";
-}
-export function isValidValue(value) {
-  if (value === null) return false;
-  if (value === void 0) return false;
-  if (typeof value === "number" && isNaN(value)) return false;
-  return true;
-}

package/dist/utils/warn.d.ts

@@ -1,2 +0,0 @@
-export declare function assert(condition: boolean, message: string): void;
-export declare function warn(...args: any[]): void;

package/dist/utils/warn.mjs

@@ -1,12 +0,0 @@
-export function assert(condition, message) {
-  if (!condition) {
-    throw new Error(`[@esmx/router] ${message}`);
-  }
-}
-export function warn(...args) {
-  console.log(
-    "%c ROUTER WARNING:",
-    "color: rgb(214, 77, 77); font-weight: bold;",
-    ...args
-  );
-}

package/src/history/abstract.ts

@@ -1,149 +0,0 @@
-import type {
-    Route,
-    RouteRecord,
-    RouterInstance,
-    RouterRawLocation
-} from '../types';
-import { isPathWithProtocolOrDomain, normalizeLocation } from '../utils';
-import { BaseRouterHistory } from './base';
-
-export class AbstractHistory extends BaseRouterHistory {
-    index: number;
-    stack: RouteRecord[];
-
-    constructor(router: RouterInstance) {
-        super(router);
-        this.index = -1;
-        this.stack = [];
-    }
-
-    async init({ replace }: { replace?: boolean } = { replace: true }) {
-        const { initUrl } = this.router.options;
-        if (initUrl !== undefined) {
-            // 存在 initUrl 则用 initUrl 进行初始化
-            if (replace) {
-                await this.replace(initUrl);
-            } else {
-                await this.push(initUrl);
-            }
-        }
-    }
-
-    destroy() {}
-
-    // 设置监听函数
-    setupListeners() {}
-
-    // 服务端判断是否是相同域名
-    isSameHost(location: RouterRawLocation, route: Route) {
-        const rawLocation =
-            typeof location === 'string' ? { path: location } : location;
-        if (rawLocation.path === undefined) {
-            rawLocation.path = this.current.fullPath;
-        }
-
-        // 服务端 base 需要包含域名，判断 base 是否包含传入路径的域名即可
-        const { base } = normalizeLocation(rawLocation, this.router.base);
-
-        return base.includes(route.hostname);
-    }
-
-    // 处理外站跳转逻辑
-    handleOutside(
-        location: RouterRawLocation,
-        replace = false,
-        isTriggerWithWindow = false
-    ) {
-        const base = this.router.base;
-        const { flag, route } = isPathWithProtocolOrDomain(location, base);
-        if (!flag) {
-            // 如果不以域名开头则跳出
-            return false;
-        }
-
-        const router = this.router;
-        const { validateOutside, handleOutside } = router.options;
-
-        // 如果域名相同 和 非外站（存在就算同域也会被视为外站的情况） 则跳出
-        const isSameHost = this.isSameHost(location, route);
-        if (isSameHost && !validateOutside?.({ router, location, route })) {
-            return false;
-        }
-
-        // 如果有配置跳转外站函数，则执行配置函数
-        handleOutside?.({
-            router,
-            route,
-            replace,
-            isTriggerWithWindow,
-            isSameHost
-        });
-
-        return true;
-    }
-
-    // 新增路由记录跳转
-    async push(location: RouterRawLocation) {
-        await this.jump(location, false);
-    }
-
-    /**
-     * 新开浏览器窗口的方法，在服务端会调用 push 作为替代
-     */
-    async pushWindow(location: RouterRawLocation) {
-        await this._jump(location, false, true);
-    }
-
-    // 替换当前路由记录跳转
-    async replace(location: RouterRawLocation) {
-        await this.jump(location, true);
-    }
-
-    /**
-     * 替换当前浏览器窗口的方法，在服务端会调用 replace 作为替代
-     */
-    async replaceWindow(location: RouterRawLocation) {
-        await this._jump(location, true, true);
-    }
-
-    // 跳转方法
-    async jump(location: RouterRawLocation, replace = false) {
-        await this._jump(location, replace);
-    }
-
-    async _jump(
-        location: RouterRawLocation,
-        replace = false,
-        isTriggerWithWindow = false
-    ) {
-        if (this.handleOutside(location, replace, isTriggerWithWindow)) {
-            return;
-        }
-
-        await this.transitionTo(location, (route) => {
-            const index = replace ? this.index : this.index + 1;
-            this.stack = this.stack.slice(0, index).concat(route);
-        });
-    }
-
-    go(delta: number): void {
-        const targetIndex = this.index + delta;
-        // 浏览器在跳转到不存在的历史记录时不会进行跳转
-        if (targetIndex < 0 || targetIndex >= this.stack.length) {
-            return;
-        }
-        const route = this.stack[targetIndex];
-        this.index = targetIndex;
-        this.updateRoute(route);
-    }
-
-    /* 路由历史记录前进方法 */
-    forward() {
-        this.go(1);
-    }
-
-    /* 路由历史记录后退方法 */
-    back() {
-        this.go(-1);
-    }
-}