@esmx/router 3.0.0-rc.50 → 3.0.0-rc.52

package/dist/matcher.mjs

@@ -1,12 +1,15 @@
 import { compile, match } from "path-to-regexp";
 export function createMatcher(routes) {
   const compiledRoutes = createRouteMatches(routes);
-  return (toURL, baseURL) => {
+  return (toURL, baseURL, cb) => {
     const matchPath = toURL.pathname.substring(baseURL.pathname.length - 1);
     const matches = [];
     const params = {};
     const collectMatchingRoutes = (routes2) => {
       for (const item of routes2) {
+        if (cb && !cb(item)) {
+          continue;
+        }
         if (item.children.length && collectMatchingRoutes(item.children)) {
           matches.unshift(item);
           return true;

package/dist/options.mjs

@@ -29,22 +29,10 @@ function getBaseUrl(options) {
   base.search = base.hash = "";
   return base;
 }
-function filterRoutesByLayer(routes, layerMode) {
-  return routes.filter((route) => {
-    if (layerMode && route.layer !== true) return false;
-    if (!layerMode && route.layer === true) return false;
-    if (route.children)
-      route.children = filterRoutesByLayer(route.children, layerMode);
-    return true;
-  });
-}
 export function parsedOptions(options = {}) {
   var _a, _b, _c, _d, _e, _f;
   const base = getBaseUrl(options);
-  const routes = filterRoutesByLayer(
-    (_a = options.routes) != null ? _a : [],
-    options.layer || false
-  );
+  const routes = (_a = options.routes) != null ? _a : [];
   return Object.freeze({
     rootStyle: options.rootStyle || false,
     root: options.root || "",

package/dist/route-transition.mjs

@@ -270,14 +270,14 @@ export class RouteTransition {
     this._controller = null;
   }
   async to(toType, toInput) {
-    var _a, _b, _c;
-    const from = (_b = (_a = this.route) == null ? void 0 : _a.clone()) != null ? _b : null;
+    var _a;
+    const from = this.route;
     const to = await this._runTask(
       new Route({
         options: this.router.parsedOptions,
         toType,
         toInput,
-        from: (_c = from == null ? void 0 : from.url) != null ? _c : null
+        from: (_a = from == null ? void 0 : from.url) != null ? _a : null
       }),
       from
     );

package/dist/route.d.ts

@@ -36,7 +36,8 @@ export declare class Route {
     readonly path: string;
     readonly fullPath: string;
     readonly hash: string;
-    readonly params: Record<string, string>;
+    readonly params: Record<string, string | undefined>;
+    readonly paramsArray: Record<string, string[] | undefined>;
     readonly query: Record<string, string | undefined>;
     readonly queryArray: Record<string, string[] | undefined>;
     readonly meta: RouteMeta;

package/dist/route.mjs

@@ -6,7 +6,7 @@ import { parsedOptions } from "./options.mjs";
 import {
   RouteType
 } from "./types.mjs";
-import { isNonEmptyPlainObject, isPlainObject } from "./util.mjs";
+import { decodeParams, isNonEmptyPlainObject, isPlainObject } from "./util.mjs";
 export const NON_ENUMERABLE_PROPERTIES = [
   // Private fields - internal implementation details
   "_handled",
@@ -66,6 +66,7 @@ export class Route {
     __publicField(this, "fullPath");
     __publicField(this, "hash");
     __publicField(this, "params", {});
+    __publicField(this, "paramsArray", {});
     __publicField(this, "query", {});
     __publicField(this, "queryArray", {});
     __publicField(this, "meta");
@@ -85,12 +86,29 @@ export class Route {
     const base = options.base;
     const toInput = resolveRouteLocationInput(routeOptions.toInput, from);
     const to = options.normalizeURL(parseLocation(toInput, base), from);
-    const isSameOrigin = to.origin === base.origin;
-    const isSameBase = to.pathname.startsWith(base.pathname);
-    const match = isSameOrigin && isSameBase ? options.matcher(to, base) : null;
+    let match = null;
+    if (to.origin === base.origin && to.pathname.startsWith(base.pathname)) {
+      const isLayer = toType === RouteType.pushLayer;
+      match = options.matcher(to, base, (config) => {
+        if (isLayer) {
+          return config.layer !== false;
+        }
+        return config.layer !== true;
+      });
+    }
     if (match) {
       applyRouteParams(match, toInput, base, to);
-      Object.assign(this.params, match.params);
+      const decodedParams = decodeParams(match.params);
+      for (const key in decodedParams) {
+        const value = decodedParams[key];
+        if (Array.isArray(value)) {
+          this.params[key] = value[0] || "";
+          this.paramsArray[key] = value;
+        } else {
+          this.params[key] = value;
+          this.paramsArray[key] = [value];
+        }
+      }
     }
     this.url = to;
     this.path = match ? to.pathname.substring(base.pathname.length - 1) : to.pathname;

package/dist/types.d.ts

@@ -91,9 +91,9 @@ export interface RouteParsedConfig extends RouteConfig {
 }
 export interface RouteMatchResult {
     readonly matches: readonly RouteParsedConfig[];
-    readonly params: Record<string, string | string[] | undefined>;
+    readonly params: Record<string, string | string[]>;
 }
-export type RouteMatcher = (targetURL: URL, baseURL: URL) => RouteMatchResult;
+export type RouteMatcher = (to: URL, base: URL, cb?: (item: RouteParsedConfig) => boolean) => RouteMatchResult;
 /**
  * Route constructor options interface
  */

package/dist/util.d.ts

@@ -24,3 +24,4 @@ export declare function isUrlEqual(url1: URL, url2?: URL | null): boolean;
  * @returns Whether they match
  */
 export declare function isRouteMatched(fromRoute: Route, toRoute: Route | null, matchType: RouteMatchType): boolean;
+export declare function decodeParams<T extends Record<string, string | string[]>>(params: T): T;

package/dist/util.mjs

@@ -51,3 +51,17 @@ export function isRouteMatched(fromRoute, toRoute, matchType) {
       return false;
   }
 }
+export function decodeParams(params) {
+  const result = {};
+  for (const key in params) {
+    const value = params[key];
+    if (Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => decodeURIComponent(item)
+      );
+    } else {
+      result[key] = decodeURIComponent(value);
+    }
+  }
+  return result;
+}

package/package.json

@@ -3,7 +3,7 @@
     "template": "library",
     "scripts": {
         "lint:js": "biome check --write --no-errors-on-unmatched",
-        "lint:css": "stylelint '**/*.{css,vue}' --fix --aei",
+        "lint:css": "npm run lint:js",
         "lint:type": "tsc --noEmit",
         "test": "vitest run --pass-with-no-tests",
         "coverage": "vitest run --coverage --pass-with-no-tests",
@@ -32,16 +32,14 @@
     },
     "devDependencies": {
         "@biomejs/biome": "1.9.4",
-        "@esmx/lint": "3.0.0-rc.50",
         "@types/node": "^24.0.0",
         "@vitest/coverage-v8": "3.2.4",
         "happy-dom": "^18.0.1",
-        "stylelint": "16.21.0",
         "typescript": "5.8.3",
         "unbuild": "3.5.0",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.50",
+    "version": "3.0.0-rc.52",
     "type": "module",
     "private": false,
     "exports": {
@@ -60,5 +58,5 @@
         "template",
         "public"
     ],
-    "gitHead": "7ec8747f78f4626941cb4da548b6df47df4df825"
+    "gitHead": "6cb46d99223f82c65b7913514950497ce34860ae"
 }

package/src/matcher.ts

@@ -3,7 +3,11 @@ import type { RouteConfig, RouteMatcher, RouteParsedConfig } from './types';
 
 export function createMatcher(routes: RouteConfig[]): RouteMatcher {
     const compiledRoutes = createRouteMatches(routes);
-    return (toURL: URL, baseURL: URL) => {
+    return (
+        toURL: URL,
+        baseURL: URL,
+        cb?: (item: RouteParsedConfig) => boolean
+    ) => {
         const matchPath = toURL.pathname.substring(baseURL.pathname.length - 1);
         const matches: RouteParsedConfig[] = [];
         const params: Record<string, string | string[]> = {};
@@ -11,6 +15,9 @@ export function createMatcher(routes: RouteConfig[]): RouteMatcher {
             routes: RouteParsedConfig[]
         ): boolean => {
             for (const item of routes) {
+                if (cb && !cb(item)) {
+                    continue;
+                }
                 // Depth-first traversal
                 if (
                     item.children.length &&

package/src/options.ts

@@ -61,27 +61,11 @@ function getBaseUrl(options: RouterOptions): URL {
     return base;
 }
 
-function filterRoutesByLayer(
-    routes: RouteConfig[],
-    layerMode: boolean
-): RouteConfig[] {
-    return routes.filter((route) => {
-        if (layerMode && route.layer !== true) return false;
-        if (!layerMode && route.layer === true) return false;
-        if (route.children)
-            route.children = filterRoutesByLayer(route.children, layerMode);
-        return true;
-    });
-}
-
 export function parsedOptions(
     options: RouterOptions = {}
 ): RouterParsedOptions {
     const base = getBaseUrl(options);
-    const routes = filterRoutesByLayer(
-        options.routes ?? [],
-        options.layer || false
-    );
+    const routes = options.routes ?? [];
     return Object.freeze<RouterParsedOptions>({
         rootStyle: options.rootStyle || false,
         root: options.root || '',

package/src/route-transition.ts

@@ -380,7 +380,7 @@ export class RouteTransition {
         toType: RouteType,
         toInput: RouteLocationInput
     ): Promise<Route> {
-        const from = this.route?.clone() ?? null;
+        const from = this.route;
         const to = await this._runTask(
             new Route({
                 options: this.router.parsedOptions,

package/src/route.ts

@@ -17,7 +17,7 @@ import {
     RouteType,
     type RouterParsedOptions
 } from './types';
-import { isNonEmptyPlainObject, isPlainObject } from './util';
+import { decodeParams, isNonEmptyPlainObject, isPlainObject } from './util';
 
 /**
  * Configuration for non-enumerable properties in Route class
@@ -120,7 +120,8 @@ export class Route {
     public readonly path: string;
     public readonly fullPath: string;
     public readonly hash: string;
-    public readonly params: Record<string, string> = {};
+    public readonly params: Record<string, string | undefined> = {};
+    public readonly paramsArray: Record<string, string[] | undefined> = {};
     public readonly query: Record<string, string | undefined> = {};
     public readonly queryArray: Record<string, string[] | undefined> = {};
     public readonly meta: RouteMeta;
@@ -153,14 +154,39 @@ export class Route {
         const base = options.base;
         const toInput = resolveRouteLocationInput(routeOptions.toInput, from);
         const to = options.normalizeURL(parseLocation(toInput, base), from);
-        const isSameOrigin = to.origin === base.origin;
-        const isSameBase = to.pathname.startsWith(base.pathname);
-        const match =
-            isSameOrigin && isSameBase ? options.matcher(to, base) : null;
+        let match: RouteMatchResult | null = null;
+
+        // Check if URL origin matches base origin (protocol + hostname + port)
+        // If origins don't match, treat as external URL and don't attempt route matching
+        if (
+            to.origin === base.origin &&
+            to.pathname.startsWith(base.pathname)
+        ) {
+            const isLayer = toType === RouteType.pushLayer;
+            match = options.matcher(to, base, (config) => {
+                if (isLayer) {
+                    return config.layer !== false;
+                }
+                return config.layer !== true;
+            });
+        }
 
         if (match) {
             applyRouteParams(match, toInput, base, to);
-            Object.assign(this.params, match.params);
+
+            const decodedParams = decodeParams(match.params);
+
+            for (const key in decodedParams) {
+                const value = decodedParams[key];
+
+                if (Array.isArray(value)) {
+                    this.params[key] = value[0] || '';
+                    this.paramsArray[key] = value;
+                } else {
+                    this.params[key] = value;
+                    this.paramsArray[key] = [value];
+                }
+            }
         }
 
         this.url = to;

package/src/types.ts

@@ -143,10 +143,14 @@ export interface RouteParsedConfig extends RouteConfig {
 
 export interface RouteMatchResult {
     readonly matches: readonly RouteParsedConfig[];
-    readonly params: Record<string, string | string[] | undefined>;
+    readonly params: Record<string, string | string[]>;
 }
 
-export type RouteMatcher = (targetURL: URL, baseURL: URL) => RouteMatchResult;
+export type RouteMatcher = (
+    to: URL,
+    base: URL,
+    cb?: (item: RouteParsedConfig) => boolean
+) => RouteMatchResult;
 
 /**
  * Route constructor options interface

package/src/util.ts

@@ -114,3 +114,22 @@ export function isRouteMatched(
             return false;
     }
 }
+
+export function decodeParams<T extends Record<string, string | string[]>>(
+    params: T
+): T {
+    const result = {} as T;
+
+    for (const key in params) {
+        const value = params[key];
+        if (Array.isArray(value)) {
+            result[key] = value.map((item) =>
+                decodeURIComponent(item)
+            ) as T[typeof key];
+        } else {
+            result[key] = decodeURIComponent(value) as T[typeof key];
+        }
+    }
+
+    return result;
+}