@esmx/router 3.0.0-rc.12

package/dist/utils/path.d.ts

@@ -0,0 +1,60 @@
+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): {
+    /**
+     * 是否以协议或域名开头
+     */
+    flag: boolean;
+    /**
+     * 虚假的 route 信息，内部跳转时无法信任，只有外站跳转时使用
+     */
+    route: Route;
+};

package/dist/utils/path.mjs

@@ -0,0 +1,264 @@
+import URLParse from "url-parse";
+import {
+  decode,
+  decodeQuery,
+  encodeHash,
+  encodeQueryKey,
+  encodeQueryValue
+} from "./encoding.mjs";
+import { isValidValue } from "./utils.mjs";
+import { warn } 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) {
+  let url = "";
+  let state = {};
+  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
+    });
+  }
+  if (regexScheme.test(url) && !regexHttpScheme.test(url)) {
+    try {
+      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
+      };
+    } catch (error) {
+      warn(error);
+    }
+  }
+  if (!/^https?:\/\//i.test(url)) {
+    url = `http://${url}`;
+  }
+  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.d.ts

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

package/dist/utils/path.spec.mjs

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,16 @@
+/**
+ * 是否在浏览器环境
+ */
+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

@@ -0,0 +1,11 @@
+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

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

package/dist/utils/warn.mjs

@@ -0,0 +1,12 @@
+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/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@esmx/router",
+    "template": "library",
+    "scripts": {
+        "lint:js": "biome check --write --no-errors-on-unmatched",
+        "lint:css": "stylelint '**/*.{css,vue}' --fix --aei",
+        "lint:type": "tsc --noEmit",
+        "test": "vitest run --pass-with-no-tests",
+        "coverage": "vitest run --coverage --pass-with-no-tests",
+        "build": "unbuild"
+    },
+    "contributors": [
+        {
+            "name": "lzxb",
+            "url": "https://github.com/lzxb"
+        },
+        {
+            "name": "RockShi1994",
+            "url": "https://github.com/RockShi1994"
+        },
+        {
+            "name": "jerrychan7",
+            "url": "https://github.com/jerrychan7"
+        },
+        {
+            "name": "wesloong",
+            "url": "https://github.com/wesloong"
+        }
+    ],
+    "dependencies": {
+        "path-to-regexp": "^6.2.2",
+        "url-parse": "^1.5.10"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "1.9.4",
+        "@esmx/lint": "3.0.0-rc.12",
+        "@gez/lint": "3.0.0-rc.9",
+        "@types/node": "22.13.10",
+        "@types/url-parse": "^1.4.11",
+        "@vitest/coverage-v8": "3.0.8",
+        "stylelint": "16.15.0",
+        "typescript": "5.8.2",
+        "unbuild": "2.0.0",
+        "vitest": "3.0.8"
+    },
+    "version": "3.0.0-rc.12",
+    "type": "module",
+    "private": false,
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "module": "dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "lib",
+        "src",
+        "dist",
+        "*.mjs",
+        "template",
+        "public"
+    ],
+    "gitHead": "7d2c2fc4fe2cc98ebdbc12560f19637ca04398e5"
+}