fix(router): inula-router路由匹配规则兼容react-router；HashHistory hash格式不合法时重定向至合法URL

packages/inula-router/src/history/hashHistory.ts

@@ -57,6 +57,13 @@ export function createHashHistory<S = DefaultStateType>(option: HashHistoryOptio
   const pathDecoder = addHeadSlash;
   const pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;
 
+  const startLocation = getHashContent(window.location.href);
+  const encodeLocation = pathEncoder(startLocation);
+  // 初始化hash格式不合法时会重定向
+  if (startLocation !== encodeLocation) {
+    window.location.replace(stripHash(window.location.href) + '#' + encodeLocation);
+  }
+
   function getLocation() {
     let hashPath = pathDecoder(getHashContent(window.location.hash));
     if (basename) {

packages/inula-router/src/router/matcher/__tests__/parser.test.ts

@@ -121,7 +121,13 @@ describe('parser test', () => {
   it('url without end slash match wildcard', function () {
     const parser = createPathParser('/about/', { strictMode: false });
     const matched = parser.parse('/about');
-    expect(matched).toBeNull();
+    expect(matched).toStrictEqual({
+      path: '/about/',
+      url: '/about',
+      score: [10],
+      isExact: true,
+      param: {},
+    });
   });
 
   it('url without end slash match wildcard (strictMode)', function () {
@@ -259,7 +265,7 @@ describe('parser test', () => {
   });
 
   it('dynamic param with complex regexp pattern', () => {
-    const parser = createPathParser('/detail/:action([\\da-z]+)', { exact: true });
+    const parser = createPathParser('/detail/:action([\\da-z]+)', { exact: true, caseSensitive: true });
     const res = parser.parse('/detail/a123');
     expect(res).toEqual({
       isExact: true,

packages/inula-router/src/router/matcher/parser.ts

@@ -97,12 +97,14 @@ export function createPathParser<P = unknown>(pathname: string, option: ParserOp
     const token = tokens[tokenIdx];
     const nextToken = tokens[tokenIdx + 1];
     switch (token.type) {
-      case TokenType.Delimiter:
-        {
+      case TokenType.Delimiter: {
+        // 该分隔符后有可选参数则该分割符在匹配时是可选的
         const hasOptional = lookToNextDelimiter(tokenIdx + 1);
-          pattern += `/${hasOptional ? '?' : ''}`;
-        }
+        // 该分割符为最后一个且strictMode===false时，该分隔符在匹配时是可选的
+        const isSlashOptional = nextToken === undefined && !strictMode;
+        pattern += `/${hasOptional || isSlashOptional ? '?' : ''}`;
         break;
+      }
       case TokenType.Static:
         pattern += token.value.replace(REGEX_CHARS_RE, '\\$&');
         if (nextToken && nextToken.type === TokenType.Pattern) {
@@ -112,8 +114,7 @@ export function createPathParser<P = unknown>(pathname: string, option: ParserOp
         }
         scores.push(MatchScore.static);
         break;
-      case TokenType.Param:
-        {
+      case TokenType.Param: {
         // 动态参数支持形如/:param、/:param*、/:param?、/:param(\\d+)的形式
         let paramRegexp = '';
         if (nextToken) {
@@ -136,8 +137,8 @@ export function createPathParser<P = unknown>(pathname: string, option: ParserOp
         pattern += paramRegexp ? `(?:${paramRegexp})` : `(${BASE_PARAM_PATTERN})`;
         keys.push(token.value);
         scores.push(MatchScore.param);
-        }
         break;
+      }
       case TokenType.WildCard:
         keys.push(token.value);
         pattern += `((?:${BASE_PARAM_PATTERN})${onlyHasWildCard ? '?' : ''}(?:/(?:${BASE_PARAM_PATTERN}))*)`;
@@ -215,16 +216,15 @@ export function createPathParser<P = unknown>(pathname: string, option: ParserOp
           }
           path += params[token.value];
           break;
-        case TokenType.WildCard:
-          {
+        case TokenType.WildCard: {
           const wildCard = params['*'];
           if (wildCard instanceof Array) {
             path += wildCard.join('/');
           } else {
             path += wildCard;
           }
-          }
           break;
+        }
         case TokenType.Delimiter:
           path += token.value;
           break;