@antdv-vue/route-utils 0.0.0-stage → 1.0.7

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @antdv-vue/route-utils
+
+## 1.0.7
+
+### Patch Changes
+
+- docs: sync structured changelog pages for every package.
+
+## 1.0.6
+
+### Patch Changes
+
+- fix bugs

package/README.md

@@ -1,3 +1,68 @@
-# Temporary Holding Version
+# @antdv-vue/route-utils
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Route transformation, menu data generation, and path matching utilities for Pro Layout.
+
+## Installation
+
+```bash
+npm install @antdv-vue/route-utils
+# or
+pnpm add @antdv-vue/route-utils
+```
+
+## What's Included
+
+| Export | Description |
+|--------|-------------|
+| `transformRoute` | Transform route configuration into menu data |
+| `getFlatMenus` | Flatten nested menu structure |
+| `getMatchMenu` | Get matched menu items by path |
+| `path-to-regexp` | Path pattern matching utilities |
+| `sha265` | SHA-256 hashing utility |
+
+## Core Types
+
+### MenuDataItem
+
+```ts
+interface MenuDataItem {
+  children?: MenuDataItem[]
+  meta?: MetaRecord
+  path: string
+  key?: string
+  name?: string | symbol
+  [key: string]: any
+}
+```
+
+### MetaRecord
+
+```ts
+interface MetaRecord {
+  hideInMenu?: boolean         // Hide this item and children from menu
+  hideChildrenInMenu?: boolean // Hide children from menu
+  icon?: any                   // Menu icon
+  title?: string               // Menu title
+  locale?: string | false      // Custom i18n key
+  [key: string]: any
+}
+```
+
+## Usage
+
+```ts
+import { transformRoute, getFlatMenus, getMatchMenu } from '@antdv-vue/route-utils'
+
+// Transform route config to menu data
+const { menuData } = transformRoute(routes)
+
+// Flatten menus
+const flatMenus = getFlatMenus(menuData)
+
+// Match current path
+const matched = getMatchMenu('/dashboard', menuData)
+```
+
+## License
+
+[MIT](../../LICENSE)

package/dist/getFlatMenus/index.d.ts

@@ -0,0 +1,11 @@
+import { MenuDataItem } from "../typing.js";
+
+//#region src/getFlatMenus/index.d.ts
+/**
+ * 获取打平的 menuData
+ * 以 path 为 key
+ * @param menuData
+ */
+declare function getFlatMenus(menuData?: MenuDataItem[]): Record<string, MenuDataItem>;
+//#endregion
+export { getFlatMenus };

package/dist/getFlatMenus/index.js

@@ -0,0 +1,24 @@
+import { stripQueryStringAndHashFromPath } from "../transformRoute/index.js";
+//#region src/getFlatMenus/index.ts
+/**
+* 获取打平的 menuData
+* 以 path 为 key
+* @param menuData
+*/
+function getFlatMenus(menuData = []) {
+	let menus = {};
+	menuData.forEach((mapItem) => {
+		const item = { ...mapItem };
+		if (!item || !item.key) return;
+		const routerChildren = item.children || [];
+		menus[stripQueryStringAndHashFromPath(item.path || item.key || "/") || ""] = { ...item };
+		menus[item.key || item.path || "/"] = { ...item };
+		if (routerChildren.length) menus = {
+			...menus,
+			...getFlatMenus(routerChildren)
+		};
+	});
+	return menus;
+}
+//#endregion
+export { getFlatMenus };

package/dist/getMatchMenu/index.d.ts

@@ -0,0 +1,20 @@
+import { MenuDataItem } from "../typing.js";
+
+//#region src/getMatchMenu/index.d.ts
+declare function getMenuMatches(flatMenuKeys: string[] | undefined, path: string, exact?: boolean): string[] | undefined;
+/**
+ * 获取当前的选中菜单列表
+ * @param path
+ * @param menuData
+ * @param fullKeys
+ * @param exact
+ * @returns MenuDataItem[]
+ */
+declare function getMatchMenu(path: string, menuData: MenuDataItem[],
+/**
+ * 要不要展示全部的 key
+ */
+
+fullKeys?: boolean, exact?: boolean): MenuDataItem[];
+//#endregion
+export { getMatchMenu, getMenuMatches };

package/dist/getMatchMenu/index.js

@@ -0,0 +1,56 @@
+import { pathToRegexp } from "../path-to-regexp.js";
+import { isUrl, stripQueryStringAndHashFromPath } from "../transformRoute/index.js";
+import { getFlatMenus } from "../getFlatMenus/index.js";
+//#region src/getMatchMenu/index.ts
+function getMenuMatches(flatMenuKeys = [], path, exact) {
+	return flatMenuKeys.filter((item) => {
+		if (item === "/" && path === "/") return true;
+		if (item !== "/" && item !== "/*" && item && !isUrl(item)) {
+			const pathKey = stripQueryStringAndHashFromPath(item);
+			try {
+				if (exact) {
+					if (pathToRegexp(`${pathKey}`).test(path)) return true;
+				}
+				if (pathToRegexp(`${pathKey}`, []).test(path)) return true;
+				if (pathToRegexp(`${pathKey}/(.*)`).test(path)) return true;
+			} catch (error) {
+				console.log(error, path);
+			}
+		}
+		return false;
+	}).sort((a, b) => {
+		if (a === path) return 10;
+		if (b === path) return -10;
+		return a.substring(1).split("/").length - b.substring(1).split("/").length;
+	});
+}
+/**
+* 获取当前的选中菜单列表
+* @param path
+* @param menuData
+* @param fullKeys
+* @param exact
+* @returns MenuDataItem[]
+*/
+function getMatchMenu(path, menuData, fullKeys, exact) {
+	const flatMenus = getFlatMenus(menuData);
+	let menuPathKeys = getMenuMatches(Object.keys(flatMenus), path || "/", exact);
+	if (!menuPathKeys || menuPathKeys.length < 1) return [];
+	if (!fullKeys) menuPathKeys = [menuPathKeys[menuPathKeys.length - 1]];
+	return (menuPathKeys || []).map((menuPathKey) => {
+		const menuItem = flatMenus[menuPathKey] || {
+			meta: { pro_layout_parentKeys: [] },
+			key: ""
+		};
+		const map = /* @__PURE__ */ new Map();
+		const parentItems = (menuItem.meta?.pro_layout_parentKeys || []).map((key) => {
+			if (map.has(key)) return null;
+			map.set(key, true);
+			return flatMenus[key];
+		}).filter((item) => item);
+		if (menuItem.key) parentItems.push(menuItem);
+		return parentItems;
+	}).flat(1);
+}
+//#endregion
+export { getMatchMenu, getMenuMatches };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { MenuDataItem, MessageDescriptor, MetaRecord } from "./typing.js";
+import { getFlatMenus } from "./getFlatMenus/index.js";
+import { getMatchMenu, getMenuMatches } from "./getMatchMenu/index.js";
+import { getKeyByPath, isUrl, stripQueryStringAndHashFromPath, transformRoute } from "./transformRoute/index.js";
+import { Key, Match, MatchFunction, MatchResult, ParseOptions, Path, PathFunction, RegexpToFunctionOptions, Token, TokensToFunctionOptions, TokensToRegexpOptions, compile, match, parse, pathToRegexp, regexpToFunction, tokensToFunction, tokensToRegexp } from "./path-to-regexp.js";
+import { sha256_encode_bytes } from "./sha265.js";
+export { Key, Match, MatchFunction, MatchResult, MenuDataItem, MessageDescriptor, MetaRecord, ParseOptions, Path, PathFunction, RegexpToFunctionOptions, Token, TokensToFunctionOptions, TokensToRegexpOptions, compile, getFlatMenus, getKeyByPath, getMatchMenu, getMenuMatches, isUrl, match, parse, pathToRegexp, regexpToFunction, sha256_encode_bytes, stripQueryStringAndHashFromPath, tokensToFunction, tokensToRegexp, transformRoute };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { compile, match, parse, pathToRegexp, regexpToFunction, tokensToFunction, tokensToRegexp } from "./path-to-regexp.js";
+import { sha256_encode_bytes } from "./sha265.js";
+import { getKeyByPath, isUrl, stripQueryStringAndHashFromPath, transformRoute } from "./transformRoute/index.js";
+import { getFlatMenus } from "./getFlatMenus/index.js";
+import { getMatchMenu, getMenuMatches } from "./getMatchMenu/index.js";
+export { compile, getFlatMenus, getKeyByPath, getMatchMenu, getMenuMatches, isUrl, match, parse, pathToRegexp, regexpToFunction, sha256_encode_bytes, stripQueryStringAndHashFromPath, tokensToFunction, tokensToRegexp, transformRoute };

package/dist/path-to-regexp.d.ts

@@ -0,0 +1,130 @@
+//#region src/path-to-regexp.d.ts
+interface ParseOptions {
+  /**
+   * Set the default delimiter for repeat parameters. (default: `'/'`)
+   */
+  delimiter?: string;
+  /**
+   * List of characters to automatically consider prefixes when parsing.
+   */
+  prefixes?: string;
+}
+/**
+ * Parse a string for the raw tokens.
+ */
+declare function parse(str: string, options?: ParseOptions): Token[];
+interface TokensToFunctionOptions {
+  /**
+   *  When `true` the regexp will be case-sensitive. (default: `false`)
+   */
+  sensitive?: boolean;
+  /**
+   * Function for encoding input strings for output.
+   */
+  encode?: (value: string, token: Key) => string;
+  /**
+   * When `false` the function can produce an invalid (unmatched) path. (default: `true`)
+   */
+  validate?: boolean;
+}
+/**
+ * Compile a string to a template function for the path.
+ */
+declare function compile<P extends object = object>(str: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
+type PathFunction<P extends object = object> = (data?: P) => string;
+/**
+ * Expose a method for transforming tokens into the path function.
+ */
+declare function tokensToFunction<P extends object = object>(tokens: Token[], options?: TokensToFunctionOptions): PathFunction<P>;
+interface RegexpToFunctionOptions {
+  /**
+   * Function for decoding strings for params.
+   */
+  decode?: (value: string, token: Key) => string;
+}
+/**
+ * A match result contains data about the path match.
+ */
+interface MatchResult<P extends object = object> {
+  path: string;
+  index: number;
+  params: P;
+}
+/**
+ * A match is either `false` (no match) or a match result.
+ */
+type Match<P extends object = object> = false | MatchResult<P>;
+/**
+ * The match function takes a string and returns whether it matched the path.
+ */
+type MatchFunction<P extends object = object> = (path: string) => Match<P>;
+/**
+ * Create path match function from `path-to-regexp` spec.
+ */
+declare function match<P extends object = object>(str: Path, options?: ParseOptions & TokensToRegexpOptions & RegexpToFunctionOptions): MatchFunction<P>;
+/**
+ * Create a path match function from `path-to-regexp` output.
+ */
+declare function regexpToFunction<P extends object = object>(re: RegExp, keys: Key[], options?: RegexpToFunctionOptions): MatchFunction<P>;
+/**
+ * Metadata about a key.
+ */
+interface Key {
+  name: string | number;
+  prefix: string;
+  suffix: string;
+  pattern: string;
+  modifier: string;
+}
+/**
+ * A token is a string (nothing special) or key metadata (capture group).
+ */
+type Token = string | Key;
+interface TokensToRegexpOptions {
+  /**
+   * When `true` the regexp will be case-sensitive. (default: `false`)
+   */
+  sensitive?: boolean;
+  /**
+   * When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`)
+   */
+  strict?: boolean;
+  /**
+   * When `true` the regexp will match to the end of the string. (default: `true`)
+   */
+  end?: boolean;
+  /**
+   * When `true` the regexp will match from the beginning of the string. (default: `true`)
+   */
+  start?: boolean;
+  /**
+   * Sets the final character for non-ending optimistic matches. (default: `/`)
+   */
+  delimiter?: string;
+  /**
+   * List of characters that can also be "end" characters.
+   */
+  endsWith?: string;
+  /**
+   * Encode path tokens for use in the `RegExp`.
+   */
+  encode?: (value: string) => string;
+}
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+declare function tokensToRegexp(tokens: Token[], keys?: Key[], options?: TokensToRegexpOptions): RegExp;
+/**
+ * Supported `path-to-regexp` input types.
+ */
+type Path = string | RegExp | Array<string | RegExp>;
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ */
+declare function pathToRegexp(path: Path, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions): RegExp;
+//#endregion
+export { Key, Match, MatchFunction, MatchResult, ParseOptions, Path, PathFunction, RegexpToFunctionOptions, Token, TokensToFunctionOptions, TokensToRegexpOptions, compile, match, parse, pathToRegexp, regexpToFunction, tokensToFunction, tokensToRegexp };

package/dist/path-to-regexp.js

@@ -0,0 +1,371 @@
+//#region src/path-to-regexp.ts
+/**
+* Tokenize input string.
+*/
+function lexer(str) {
+	const tokens = [];
+	let i = 0;
+	while (i < str.length) {
+		const char = str[i];
+		if (char === "*" || char === "+" || char === "?") {
+			tokens.push({
+				type: "MODIFIER",
+				index: i,
+				value: str[i++] || ""
+			});
+			continue;
+		}
+		if (char === "\\") {
+			tokens.push({
+				type: "ESCAPED_CHAR",
+				index: i++,
+				value: str[i++] || ""
+			});
+			continue;
+		}
+		if (char === "{") {
+			tokens.push({
+				type: "OPEN",
+				index: i,
+				value: str[i++] || ""
+			});
+			continue;
+		}
+		if (char === "}") {
+			tokens.push({
+				type: "CLOSE",
+				index: i,
+				value: str[i++] || ""
+			});
+			continue;
+		}
+		if (char === ":") {
+			let name = "";
+			let j = i + 1;
+			while (j < str.length) {
+				const code = str.charCodeAt(j);
+				if (code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95) {
+					name += str[j++];
+					continue;
+				}
+				break;
+			}
+			if (!name) throw new TypeError(`Missing parameter name at ${i}`);
+			tokens.push({
+				type: "NAME",
+				index: i,
+				value: name
+			});
+			i = j;
+			continue;
+		}
+		if (char === "(") {
+			let count = 1;
+			let pattern = "";
+			let j = i + 1;
+			if (str[j] === "?") throw new TypeError(`Pattern cannot start with "?" at ${j}`);
+			while (j < str.length) {
+				if (str[j] === "\\") {
+					pattern += (str[j++] || "") + str[j++];
+					continue;
+				}
+				if (str[j] === ")") {
+					count--;
+					if (count === 0) {
+						j++;
+						break;
+					}
+				} else if (str[j] === "(") {
+					count++;
+					if (str[j + 1] !== "?") throw new TypeError(`Capturing groups are not allowed at ${j}`);
+				}
+				pattern += str[j++];
+			}
+			if (count) throw new TypeError(`Unbalanced pattern at ${i}`);
+			if (!pattern) throw new TypeError(`Missing pattern at ${i}`);
+			tokens.push({
+				type: "PATTERN",
+				index: i,
+				value: pattern
+			});
+			i = j;
+			continue;
+		}
+		tokens.push({
+			type: "CHAR",
+			index: i,
+			value: str[i++] || ""
+		});
+	}
+	tokens.push({
+		type: "END",
+		index: i,
+		value: ""
+	});
+	return tokens;
+}
+/**
+* Parse a string for the raw tokens.
+*/
+function parse(str, options = {}) {
+	const tokens = lexer(str);
+	const { prefixes = "./", delimiter = "/#?" } = options;
+	const result = [];
+	let key = 0;
+	let i = 0;
+	let path = "";
+	const tryConsume = (type) => {
+		if (i < tokens.length && tokens[i]?.type === type) return tokens[i++]?.value;
+	};
+	const mustConsume = (type) => {
+		const value = tryConsume(type);
+		if (value !== void 0) return value;
+		const { type: nextType, index } = tokens[i] || {};
+		throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}`);
+	};
+	const consumeText = () => {
+		let result = "";
+		let value;
+		while (value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) result += value;
+		return result;
+	};
+	const isSafe = (value) => {
+		for (const char of delimiter) if (value.includes(char)) return true;
+		return false;
+	};
+	const safePattern = (prefix) => {
+		const prev = result[result.length - 1];
+		const prevText = prefix || (prev && typeof prev === "string" ? prev : "");
+		if (prev && !prevText) throw new TypeError(`Must have text between two parameters, missing text after "${prev.name}"`);
+		if (!prevText || isSafe(prevText)) return `[^${escapeString(delimiter)}]+?`;
+		return `(?:(?!${escapeString(prevText)})[^${escapeString(delimiter)}])+?`;
+	};
+	while (i < tokens.length) {
+		const char = tryConsume("CHAR");
+		const name = tryConsume("NAME");
+		const pattern = tryConsume("PATTERN");
+		if (name || pattern) {
+			let prefix = char || "";
+			if (!prefixes.includes(prefix)) {
+				path += prefix;
+				prefix = "";
+			}
+			if (path) {
+				result.push(path);
+				path = "";
+			}
+			result.push({
+				name: name || key++,
+				prefix,
+				suffix: "",
+				pattern: pattern || safePattern(prefix),
+				modifier: tryConsume("MODIFIER") || ""
+			});
+			continue;
+		}
+		const value = char || tryConsume("ESCAPED_CHAR");
+		if (value) {
+			path += value;
+			continue;
+		}
+		if (path) {
+			result.push(path);
+			path = "";
+		}
+		if (tryConsume("OPEN")) {
+			const prefix = consumeText();
+			const name = tryConsume("NAME") || "";
+			const pattern = tryConsume("PATTERN") || "";
+			const suffix = consumeText();
+			mustConsume("CLOSE");
+			result.push({
+				name: name || (pattern ? key++ : ""),
+				pattern: name && !pattern ? safePattern(prefix) : pattern,
+				prefix,
+				suffix,
+				modifier: tryConsume("MODIFIER") || ""
+			});
+			continue;
+		}
+		mustConsume("END");
+	}
+	return result;
+}
+/**
+* Compile a string to a template function for the path.
+*/
+function compile(str, options) {
+	return tokensToFunction(parse(str, options), options);
+}
+/**
+* Expose a method for transforming tokens into the path function.
+*/
+function tokensToFunction(tokens, options = {}) {
+	const reFlags = flags(options);
+	const { encode = (x) => x, validate = true } = options;
+	const matches = tokens.map((token) => {
+		if (typeof token === "object") return new RegExp(`^(?:${token.pattern})$`, reFlags);
+	});
+	return (data) => {
+		let path = "";
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			if (typeof token === "string") {
+				path += token;
+				continue;
+			}
+			const value = data ? data[token?.name || ""] : void 0;
+			const optional = token?.modifier === "?" || token?.modifier === "*";
+			const repeat = token?.modifier === "*" || token?.modifier === "+";
+			if (Array.isArray(value)) {
+				if (!repeat) throw new TypeError(`Expected "${token?.name}" to not repeat, but got an array`);
+				if (value.length === 0) {
+					if (optional) continue;
+					throw new TypeError(`Expected "${token.name}" to not be empty`);
+				}
+				for (let j = 0; j < value.length; j++) {
+					const segment = encode(value[j], token);
+					if (validate && !matches[i].test(segment)) throw new TypeError(`Expected all "${token.name}" to match "${token.pattern}", but got "${segment}"`);
+					path += token.prefix + segment + token.suffix;
+				}
+				continue;
+			}
+			if (typeof value === "string" || typeof value === "number") {
+				const segment = encode(String(value), token);
+				if (validate && !matches[i].test(segment)) throw new TypeError(`Expected "${token?.name}" to match "${token?.pattern}", but got "${segment}"`);
+				path += token?.prefix + segment + token?.suffix;
+				continue;
+			}
+			if (optional) continue;
+			const typeOfMessage = repeat ? "an array" : "a string";
+			throw new TypeError(`Expected "${token?.name}" to be ${typeOfMessage}`);
+		}
+		return path;
+	};
+}
+/**
+* Create path match function from `path-to-regexp` spec.
+*/
+function match(str, options) {
+	const keys = [];
+	return regexpToFunction(pathToRegexp(str, keys, options), keys, options);
+}
+/**
+* Create a path match function from `path-to-regexp` output.
+*/
+function regexpToFunction(re, keys, options = {}) {
+	const { decode = (x) => x } = options;
+	return function(pathname) {
+		const m = re.exec(pathname);
+		if (!m) return false;
+		const { 0: path, index } = m;
+		const params = Object.create(null);
+		for (let i = 1; i < m.length; i++) {
+			if (m[i] === void 0) continue;
+			const key = keys[i - 1];
+			if (key.modifier === "*" || key.modifier === "+") params[key.name] = m[i]?.split(key.prefix + key.suffix).map((value) => {
+				return decode(value, key);
+			});
+			else params[key.name] = decode(m[i], key);
+		}
+		return {
+			path,
+			index,
+			params
+		};
+	};
+}
+/**
+* Escape a regular expression string.
+*/
+function escapeString(str) {
+	return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+}
+/**
+* Get the flags for a regexp from the options.
+*/
+function flags(options) {
+	return options && options.sensitive ? "" : "i";
+}
+/**
+* Pull out keys from a regexp.
+*/
+function regexpToRegexp(path, keys) {
+	if (!keys) return path;
+	const groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+	let index = 0;
+	let execResult = groupsRegex.exec(path.source);
+	while (execResult) {
+		keys.push({
+			name: execResult[1] || index++,
+			prefix: "",
+			suffix: "",
+			modifier: "",
+			pattern: ""
+		});
+		execResult = groupsRegex.exec(path.source);
+	}
+	return path;
+}
+/**
+* Transform an array into a regexp.
+*/
+function arrayToRegexp(paths, keys, options) {
+	const parts = paths.map((path) => pathToRegexp(path, keys, options).source);
+	return new RegExp(`(?:${parts.join("|")})`, flags(options));
+}
+/**
+* Create a path regexp from string input.
+*/
+function stringToRegexp(path, keys, options) {
+	return tokensToRegexp(parse(path, options), keys, options);
+}
+/**
+* Expose a function for taking tokens and returning a RegExp.
+*/
+function tokensToRegexp(tokens, keys, options = {}) {
+	const { strict = false, start = true, end = true, encode = (x) => x, delimiter = "/#?", endsWith = "" } = options;
+	const endsWithRe = `[${escapeString(endsWith)}]|$`;
+	const delimiterRe = `[${escapeString(delimiter)}]`;
+	let route = start ? "^" : "";
+	for (const token of tokens) if (typeof token === "string") route += escapeString(encode(token));
+	else {
+		const prefix = escapeString(encode(token.prefix));
+		const suffix = escapeString(encode(token.suffix));
+		if (token.pattern) {
+			if (keys) keys.push(token);
+			if (prefix || suffix) if (token.modifier === "+" || token.modifier === "*") {
+				const mod = token.modifier === "*" ? "?" : "";
+				route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`;
+			} else route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+			else {
+				if (token.modifier === "+" || token.modifier === "*") throw new TypeError(`Can not repeat "${token.name}" without a prefix and suffix`);
+				route += `(${token.pattern})${token.modifier}`;
+			}
+		} else route += `(?:${prefix}${suffix})${token.modifier}`;
+	}
+	if (end) {
+		if (!strict) route += `${delimiterRe}?`;
+		route += !options.endsWith ? "$" : `(?=${endsWithRe})`;
+	} else {
+		const endToken = tokens[tokens.length - 1];
+		const isEndDelimited = typeof endToken === "string" ? delimiterRe.includes(endToken[endToken.length - 1]) : endToken === void 0;
+		if (!strict) route += `(?:${delimiterRe}(?=${endsWithRe}))?`;
+		if (!isEndDelimited) route += `(?=${delimiterRe}|${endsWithRe})`;
+	}
+	return new RegExp(route, flags(options));
+}
+/**
+* Normalize the given path string, returning a regular expression.
+*
+* An empty array can be passed in for the keys, which will hold the
+* placeholder key descriptions. For example, using `/user/:id`, `keys` will
+* contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+*/
+function pathToRegexp(path, keys, options) {
+	if (path instanceof RegExp) return regexpToRegexp(path, keys);
+	if (Array.isArray(path)) return arrayToRegexp(path, keys, options);
+	return stringToRegexp(path, keys, options);
+}
+//#endregion
+export { compile, match, parse, pathToRegexp, regexpToFunction, tokensToFunction, tokensToRegexp };

package/dist/sha265.d.ts

@@ -0,0 +1,5 @@
+//#region src/sha265.d.ts
+declare function sha256_encode_bytes(): unknown[];
+declare function digest(data: string): string;
+//#endregion
+export { digest as default, sha256_encode_bytes };

package/dist/sha265.js

@@ -0,0 +1,218 @@
+//#region src/sha265.ts
+function rotateRight(n, x) {
+	return x >>> n | x << 32 - n;
+}
+function choice(x, y, z) {
+	return x & y ^ ~x & z;
+}
+function majority(x, y, z) {
+	return x & y ^ x & z ^ y & z;
+}
+function sha256_Sigma0(x) {
+	return rotateRight(2, x) ^ rotateRight(13, x) ^ rotateRight(22, x);
+}
+function sha256_Sigma1(x) {
+	return rotateRight(6, x) ^ rotateRight(11, x) ^ rotateRight(25, x);
+}
+function sha256_sigma0(x) {
+	return rotateRight(7, x) ^ rotateRight(18, x) ^ x >>> 3;
+}
+function sha256_sigma1(x) {
+	return rotateRight(17, x) ^ rotateRight(19, x) ^ x >>> 10;
+}
+function sha256_expand(W, j) {
+	return W[j & 15] += sha256_sigma1(W[j + 14 & 15]) + W[j + 9 & 15] + sha256_sigma0(W[j + 1 & 15]);
+}
+const K256 = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+/**
+* global arrays
+*/
+let ihash;
+let count;
+let buffer;
+const sha256_hex_digits = "0123456789abcdef";
+function safe_add(x, y) {
+	const lsw = (x & 65535) + (y & 65535);
+	return (x >> 16) + (y >> 16) + (lsw >> 16) << 16 | lsw & 65535;
+}
+function sha256_init() {
+	ihash = Array.from({ length: 8 });
+	count = Array.from({ length: 2 });
+	buffer = Array.from({ length: 64 });
+	count[0] = count[1] = 0;
+	ihash[0] = 1779033703;
+	ihash[1] = 3144134277;
+	ihash[2] = 1013904242;
+	ihash[3] = 2773480762;
+	ihash[4] = 1359893119;
+	ihash[5] = 2600822924;
+	ihash[6] = 528734635;
+	ihash[7] = 1541459225;
+}
+function sha256_transform() {
+	let a;
+	let b;
+	let c;
+	let d;
+	let e;
+	let f;
+	let g;
+	let h;
+	let T1;
+	let T2;
+	const W = Array.from({ length: 16 });
+	a = ihash[0];
+	b = ihash[1];
+	c = ihash[2];
+	d = ihash[3];
+	e = ihash[4];
+	f = ihash[5];
+	g = ihash[6];
+	h = ihash[7];
+	for (let i = 0; i < 16; i++) W[i] = buffer[(i << 2) + 3] | buffer[(i << 2) + 2] << 8 | buffer[(i << 2) + 1] << 16 | buffer[i << 2] << 24;
+	for (let j = 0; j < 64; j++) {
+		T1 = h + sha256_Sigma1(e) + choice(e, f, g) + K256[j];
+		if (j < 16) T1 += W[j];
+		else T1 += sha256_expand(W, j);
+		T2 = sha256_Sigma0(a) + majority(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = safe_add(d, T1);
+		d = c;
+		c = b;
+		b = a;
+		a = safe_add(T1, T2);
+	}
+	ihash[0] += a;
+	ihash[1] += b;
+	ihash[2] += c;
+	ihash[3] += d;
+	ihash[4] += e;
+	ihash[5] += f;
+	ihash[6] += g;
+	ihash[7] += h;
+}
+function sha256_update(data, inputLen) {
+	let i;
+	let index;
+	let curpos = 0;
+	index = count[0] >> 3 & 63;
+	const remainder = inputLen & 63;
+	if ((count[0] += inputLen << 3) < inputLen << 3) count[1]++;
+	count[1] += inputLen >> 29;
+	for (i = 0; i + 63 < inputLen; i += 64) {
+		for (let j = index; j < 64; j++) buffer[j] = data.charCodeAt(curpos++);
+		sha256_transform();
+		index = 0;
+	}
+	for (let j = 0; j < remainder; j++) buffer[j] = data.charCodeAt(curpos++);
+}
+function sha256_final() {
+	let index = count[0] >> 3 & 63;
+	buffer[index++] = 128;
+	if (index <= 56) for (let i = index; i < 56; i++) buffer[i] = 0;
+	else {
+		for (let i = index; i < 64; i++) buffer[i] = 0;
+		sha256_transform();
+		for (let i = 0; i < 56; i++) buffer[i] = 0;
+	}
+	buffer[56] = count[1] >>> 24 & 255;
+	buffer[57] = count[1] >>> 16 & 255;
+	buffer[58] = count[1] >>> 8 & 255;
+	buffer[59] = count[1] & 255;
+	buffer[60] = count[0] >>> 24 & 255;
+	buffer[61] = count[0] >>> 16 & 255;
+	buffer[62] = count[0] >>> 8 & 255;
+	buffer[63] = count[0] & 255;
+	sha256_transform();
+}
+function sha256_encode_bytes() {
+	let j = 0;
+	const output = Array.from({ length: 32 });
+	for (let i = 0; i < 8; i++) {
+		output[j++] = ihash[i] >>> 24 & 255;
+		output[j++] = ihash[i] >>> 16 & 255;
+		output[j++] = ihash[i] >>> 8 & 255;
+		output[j++] = ihash[i] & 255;
+	}
+	return output;
+}
+function sha256_encode_hex() {
+	let output = String();
+	for (let i = 0; i < 8; i++) for (let j = 28; j >= 0; j -= 4) output += sha256_hex_digits.charAt(ihash[i] >>> j & 15);
+	return output;
+}
+function digest(data) {
+	sha256_init();
+	sha256_update(data, data.length);
+	sha256_final();
+	return sha256_encode_hex();
+}
+//#endregion
+export { digest as default, sha256_encode_bytes };

package/dist/transformRoute/index.d.ts

@@ -0,0 +1,17 @@
+import { MenuDataItem, MessageDescriptor } from "../typing.js";
+
+//#region src/transformRoute/index.d.ts
+declare const stripQueryStringAndHashFromPath: (url: string) => string | undefined;
+declare function isUrl(path: string): boolean;
+declare function getKeyByPath(item: MenuDataItem): string | undefined;
+/**
+ * @param routeList 路由配置
+ * @param locale 是否使用国际化
+ * @param formatMessage 国际化的程序
+ */
+declare function transformRoute(routeList: MenuDataItem[], locale?: boolean, formatMessage?: (message: MessageDescriptor) => string | undefined): {
+  breadcrumb: Map<string, MenuDataItem>;
+  menuData: MenuDataItem[];
+};
+//#endregion
+export { getKeyByPath, isUrl, stripQueryStringAndHashFromPath, transformRoute };

package/dist/transformRoute/index.js

@@ -0,0 +1,208 @@
+import { pathToRegexp } from "../path-to-regexp.js";
+import digest from "../sha265.js";
+//#region src/transformRoute/index.ts
+const stripQueryStringAndHashFromPath = (url) => url.split("?")[0]?.split("#")[0];
+function isUrl(path) {
+	if (!path.startsWith("http")) return false;
+	try {
+		return !!new URL(path);
+	} catch (error) {
+		console.log(error);
+		return false;
+	}
+}
+function getKeyByPath(item) {
+	const { path } = item;
+	if (!path || path === "/") try {
+		return `/${digest(JSON.stringify(item))}`;
+	} catch (error) {
+		console.log(error);
+	}
+	return path ? stripQueryStringAndHashFromPath(path) : path;
+}
+/**
+* 如果不是 / 开头的和父节点做一下合并
+* 如果是 / 开头的不作任何处理
+* 如果是 url 也直接返回
+* @param path
+* @param parentPath
+*/
+function mergePath(path = "", parentPath = "/") {
+	if ((path || parentPath).startsWith("/")) return path;
+	if (isUrl(path)) return path;
+	return `/${parentPath}/${path}`.replace(/\/\//g, "/").replace(/\/\//g, "/");
+}
+/**
+* 获取locale，增加了一个功能，如果 locale = false，将不使用国际化
+* @param item
+* @param parentTitle
+*/
+function getItemLocaleName(item, parentTitle) {
+	const { meta } = item;
+	if ("locale" in meta && meta?.locale === false || !meta?.title) return false;
+	return item.meta?.locale || `${parentTitle}.${meta?.title.toString().toLowerCase()}`;
+}
+const notNullArray = (value) => Array.isArray(value) && value.length > 0;
+/**
+*
+* @param props
+* @param parent
+*/
+function formatter(props, parent = { path: "/" }) {
+	const { data, formatMessage, parentTitle, locale: menuLocale } = props;
+	if (!data || !Array.isArray(data)) return [];
+	return data.filter((item) => {
+		if (!item) return false;
+		if (notNullArray(item.children)) return true;
+		if (item.path) return true;
+		if (item.redirect) return false;
+		return false;
+	}).map((item = { path: "/" }) => {
+		const routerChildren = item.children || [];
+		const path = mergePath(item.path, parent ? parent.path : "/");
+		const { title } = item.meta;
+		const locale = getItemLocaleName(item, parentTitle || "menu");
+		const localeTitle = locale !== false && menuLocale !== false && formatMessage && locale ? formatMessage({
+			id: locale,
+			defaultMessage: title
+		}) : title;
+		const { children, meta, redirect, ...restParent } = parent;
+		let finallyItem = {
+			...restParent,
+			...item,
+			meta: {
+				...item.meta,
+				pro_layout_parentKeys: [],
+				locale
+			},
+			key: item.key || getKeyByPath({
+				...item,
+				path
+			}),
+			path
+		};
+		if (meta) {
+			const { flatMenu, pro_layout_parentKeys = [], icon, ...restParentMeta } = meta;
+			const item_pro_layout_parentKeys = new Set([...pro_layout_parentKeys, ...item.meta?.parentKeys || []]);
+			if (parent.key) item_pro_layout_parentKeys.add(parent.key);
+			finallyItem = {
+				...restParent,
+				...item,
+				meta: {
+					...restParentMeta,
+					...item.meta,
+					pro_layout_parentKeys: Array.from(item_pro_layout_parentKeys).filter((key) => key && key !== "/"),
+					locale
+				},
+				key: item.key || getKeyByPath({
+					...item,
+					path
+				}),
+				path
+			};
+		}
+		if (finallyItem.meta) if (localeTitle) finallyItem.meta.title = localeTitle;
+		else delete finallyItem.meta.title;
+		if (notNullArray(routerChildren)) {
+			const formatterChildren = formatter({
+				...props,
+				data: routerChildren,
+				parentTitle: locale || ""
+			}, finallyItem);
+			if (notNullArray(formatterChildren)) finallyItem.children = formatterChildren;
+		}
+		return bigfishConversions(finallyItem, props);
+	}).flat(1);
+}
+function bigfishConversions(route, props) {
+	const childrenList = route.children || [];
+	const result = { ...route };
+	if (childrenList && childrenList.length) {
+		/** 在菜单中隐藏子项 */
+		if (result.meta?.hideChildrenInMenu) {
+			delete result.children;
+			return result;
+		}
+		const finalChildren = formatter({
+			...props,
+			data: childrenList
+		}, route);
+		/** 在菜单中只隐藏此项，子项往上提，仍旧展示 */
+		if (result.meta?.flatMenu) return finalChildren;
+	}
+	return result;
+}
+/**
+* 删除 hideInMenu 和 title 不存在的
+*/
+function filterMenuData(menuData = []) {
+	return menuData.filter((item) => item && item.meta && item.meta.title && !item.meta.hideInMenu || notNullArray(item.children)).map((item) => {
+		const newItem = { ...item };
+		const routerChildren = newItem.children || [];
+		if (notNullArray(routerChildren) && newItem.meta && !newItem.meta.hideChildrenInMenu && routerChildren.some((child) => child && child.meta && !!child.meta.title)) {
+			const newChildren = filterMenuData(routerChildren);
+			if (newChildren.length) return {
+				...newItem,
+				children: newChildren
+			};
+		}
+		return { ...item };
+	}).filter((item) => item);
+}
+/**
+* support pathToRegexp get string
+*/
+var RouteListMap = class extends Map {
+	get(pathname) {
+		let routeValue;
+		try {
+			for (const [key, value] of this.entries()) {
+				const path = stripQueryStringAndHashFromPath(key);
+				if (!isUrl(key) && pathToRegexp(path || "", []).test(pathname)) {
+					routeValue = value;
+					break;
+				}
+			}
+		} catch (error) {
+			console.log(error);
+			routeValue = void 0;
+		}
+		return routeValue;
+	}
+};
+/**
+* 获取面包屑映射
+* @param menuData 菜单配置
+*/
+function getBreadcrumbNameMap(menuData) {
+	const routerMap = new RouteListMap();
+	const flattenMenuData = (data, parent) => {
+		data.forEach((menuItem) => {
+			const routerChildren = menuItem.children || [];
+			if (notNullArray(routerChildren)) flattenMenuData(routerChildren, menuItem);
+			const path = mergePath(menuItem.path, parent ? parent.path : "/");
+			if (!isUrl(path)) routerMap.set(stripQueryStringAndHashFromPath(path) || "", menuItem);
+		});
+	};
+	flattenMenuData(menuData);
+	return routerMap;
+}
+/**
+* @param routeList 路由配置
+* @param locale 是否使用国际化
+* @param formatMessage 国际化的程序
+*/
+function transformRoute(routeList, locale, formatMessage) {
+	const originalMenuData = formatter({
+		data: routeList,
+		formatMessage,
+		locale
+	});
+	const menuData = filterMenuData(originalMenuData);
+	return {
+		breadcrumb: getBreadcrumbNameMap(originalMenuData),
+		menuData
+	};
+}
+//#endregion
+export { getKeyByPath, isUrl, stripQueryStringAndHashFromPath, transformRoute };

package/dist/typing.d.ts

@@ -0,0 +1,31 @@
+//#region src/typing.d.ts
+interface MessageDescriptor {
+  id: string;
+  description?: string;
+  defaultMessage?: string;
+}
+interface MetaRecord {
+  /** @name hideInMenu 在菜单中隐藏自己和子节点 */
+  hideInMenu?: boolean;
+  /** @name hideChildrenInMenu 在菜单中隐藏子节点 */
+  hideChildrenInMenu?: boolean;
+  /** @name icon 菜单的icon */
+  icon?: any;
+  /** @name title 菜单的标题 */
+  title?: string;
+  /** @name locale 自定义菜单的国际化 key */
+  locale?: string | false;
+  pro_layout_parentKeys?: string[];
+  parentKeys?: string[];
+  [key: string]: any;
+}
+interface MenuDataItem {
+  children?: MenuDataItem[];
+  meta?: MetaRecord;
+  path: string;
+  key?: string;
+  name?: string | symbol;
+  [key: string]: any;
+}
+//#endregion
+export { MenuDataItem, MessageDescriptor, MetaRecord };

package/dist/typing.js

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

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@antdv-vue/route-utils",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "1.0.7",
+  "description": "@antdv-vue/route-utils",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bunnyblueair/pro-components.git",
+    "directory": "packages/route-utils"
+  },
+  "keywords": [],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./route-utils": {
+      "types": "./dist/route-utils/index.d.ts",
+      "import": "./dist/route-utils/index.js",
+      "default": "./dist/route-utils/index.js"
+    },
+    "./dist/*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "CHANGELOG.md",
+    "dist",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "yarn build",
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "authors": [
+    "lucasjeke <lucasjekeqd@gmail.com> (https://github.com/lucasjeke)"
+  ]
 }