@esmx/router 3.0.0-rc.82 → 3.0.0-rc.84

package/dist/options.mjs

@@ -38,6 +38,7 @@ export function parsedOptions(options = {}) {
     rootStyle: options.rootStyle || false,
     root: options.root || "",
     context: options.context || {},
+    data: options.data || {},
     req: options.req || null,
     res: options.res || null,
     layer: options.layer || false,

package/dist/router.d.ts

@@ -13,6 +13,7 @@ export declare class Router {
     readonly transition: RouteTransition;
     get route(): Route;
     get context(): Record<string | symbol, unknown>;
+    get data(): Record<string | symbol, unknown>;
     get root(): string | HTMLElement;
     get mode(): RouterMode;
     get base(): URL;

package/dist/router.mjs

@@ -44,6 +44,9 @@ export class Router {
   get context() {
     return this.parsedOptions.context;
   }
+  get data() {
+    return this.parsedOptions.data;
+  }
   get root() {
     return this.parsedOptions.root;
   }
@@ -257,24 +260,44 @@ export class Router {
       },
       layer: true
     });
-    await router.replace(toInput);
-    router.afterEach((to, from) => {
-      if (layerOptions.shouldClose && ![
+    const initRoute = await router.replace(toInput);
+    router.afterEach(async (to, from) => {
+      if (![
         RouteType.pushWindow,
         RouteType.replaceWindow,
         RouteType.replace,
         RouteType.restartApp,
         RouteType.pushLayer
-      ].includes(to.type)) {
-        const result = layerOptions.shouldClose(to, from, router);
-        if (result === true) {
-          router.destroy();
-          promiseResolve({
-            type: "push",
-            route: to
-          });
+      ].includes(to.type))
+        return;
+      let keepAlive = false;
+      if (layerOptions.keepAlive === "exact") {
+        keepAlive = to.path === initRoute.path;
+      } else if (layerOptions.keepAlive === "include") {
+        keepAlive = to.path.startsWith(initRoute.path);
+      } else if (typeof layerOptions.keepAlive === "function") {
+        keepAlive = await layerOptions.keepAlive(to, from, router);
+      } else {
+        if (layerOptions.shouldClose) {
+          console.warn(
+            "[esmx-router] RouteLayerOptions.shouldClose is deprecated. Use keepAlive instead. Note: shouldClose returns true to close, keepAlive returns true to keep alive."
+          );
+          keepAlive = !await layerOptions.shouldClose(
+            to,
+            from,
+            router
+          );
+        } else {
+          keepAlive = to.path === initRoute.path;
         }
       }
+      if (!keepAlive) {
+        router.destroy();
+        promiseResolve({
+          type: "push",
+          route: to
+        });
+      }
     });
     if (layerOptions.push) {
       router.navigation.pushHistoryState(

package/dist/types.d.ts

@@ -115,6 +115,27 @@ export interface RouteLayerOptions {
      */
     zIndex?: number;
     /**
+     * Hook function to determine layer keep-alive behavior before route closure
+     * Determines whether the layer should remain open during navigation
+     * - 'exact': Keep layer alive only when navigating to the exact initial path (default)
+     * - 'include': Keep layer alive when navigating to paths that start with the initial path
+     * - function: Custom logic to determine if the layer should be kept alive
+     * @default 'exact'
+     * @example
+     * ```typescript
+     * // Default behavior - keep only when navigating back to initial path
+     * keepAlive: 'exact'
+     *
+     * // Keep layer alive for all sub-paths (paths starting with the initial path)
+     * keepAlive: 'include'
+     *
+     * // Custom logic
+     * keepAlive: (to, from, router) => to.query.keepLayer === 'true'
+     * ```
+     */
+    keepAlive?: 'exact' | 'include' | RouteVerifyHook;
+    /**
+     * @deprecated Use keepAlive instead
      * Verification hook function before route closure
      * @returns Return true to allow closure, false to prevent closure
      */
@@ -186,6 +207,7 @@ export interface RouterOptions {
      */
     root?: string | HTMLElement;
     context?: Record<string | symbol, unknown>;
+    data?: Record<string | symbol, unknown>;
     routes?: RouteConfig[];
     mode?: RouterMode;
     /** Optional in browser, but required on server side */

package/package.json

@@ -39,7 +39,7 @@
         "unbuild": "3.6.1",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.82",
+    "version": "3.0.0-rc.84",
     "type": "module",
     "private": false,
     "exports": {
@@ -58,5 +58,5 @@
         "template",
         "public"
     ],
-    "gitHead": "8dd1d8bca1d37902915fef48c1949dba3c1afcf8"
+    "gitHead": "21f81d3d3083f4008b491d7d906d772ffb537007"
 }

package/src/options.ts

@@ -66,6 +66,7 @@ export function parsedOptions(
         rootStyle: options.rootStyle || false,
         root: options.root || '',
         context: options.context || {},
+        data: options.data || {},
         req: options.req || null,
         res: options.res || null,
         layer: options.layer || false,

package/src/router.ts

@@ -43,6 +43,9 @@ export class Router {
     public get context() {
         return this.parsedOptions.context;
     }
+    public get data() {
+        return this.parsedOptions.data;
+    }
 
     public get root() {
         return this.parsedOptions.root;
@@ -289,11 +292,10 @@ export class Router {
             },
             layer: true
         });
-        await router.replace(toInput);
+        const initRoute = await router.replace(toInput);
 
-        router.afterEach((to, from) => {
+        router.afterEach(async (to, from) => {
             if (
-                layerOptions.shouldClose &&
                 ![
                     RouteType.pushWindow,
                     RouteType.replaceWindow,
@@ -301,16 +303,37 @@ export class Router {
                     RouteType.restartApp,
                     RouteType.pushLayer
                 ].includes(to.type)
-            ) {
-                const result = layerOptions.shouldClose(to, from, router);
-                if (result === true) {
-                    router.destroy();
-                    promiseResolve({
-                        type: 'push',
-                        route: to
-                    });
+            )
+                return;
+            let keepAlive = false;
+            if (layerOptions.keepAlive === 'exact') {
+                keepAlive = to.path === initRoute.path;
+            } else if (layerOptions.keepAlive === 'include') {
+                keepAlive = to.path.startsWith(initRoute.path);
+            } else if (typeof layerOptions.keepAlive === 'function') {
+                keepAlive = await layerOptions.keepAlive(to, from, router);
+            } else {
+                if (layerOptions.shouldClose) {
+                    console.warn(
+                        '[esmx-router] RouteLayerOptions.shouldClose is deprecated. Use keepAlive instead. ' +
+                            'Note: shouldClose returns true to close, keepAlive returns true to keep alive.'
+                    );
+                    keepAlive = !(await layerOptions.shouldClose(
+                        to,
+                        from,
+                        router
+                    ));
+                } else {
+                    keepAlive = to.path === initRoute.path;
                 }
             }
+            if (!keepAlive) {
+                router.destroy();
+                promiseResolve({
+                    type: 'push',
+                    route: to
+                });
+            }
         });
         if (layerOptions.push) {
             router.navigation.pushHistoryState(

package/src/types.ts

@@ -177,6 +177,27 @@ export interface RouteLayerOptions {
      */
     zIndex?: number;
     /**
+     * Hook function to determine layer keep-alive behavior before route closure
+     * Determines whether the layer should remain open during navigation
+     * - 'exact': Keep layer alive only when navigating to the exact initial path (default)
+     * - 'include': Keep layer alive when navigating to paths that start with the initial path
+     * - function: Custom logic to determine if the layer should be kept alive
+     * @default 'exact'
+     * @example
+     * ```typescript
+     * // Default behavior - keep only when navigating back to initial path
+     * keepAlive: 'exact'
+     *
+     * // Keep layer alive for all sub-paths (paths starting with the initial path)
+     * keepAlive: 'include'
+     *
+     * // Custom logic
+     * keepAlive: (to, from, router) => to.query.keepLayer === 'true'
+     * ```
+     */
+    keepAlive?: 'exact' | 'include' | RouteVerifyHook;
+    /**
+     * @deprecated Use keepAlive instead
      * Verification hook function before route closure
      * @returns Return true to allow closure, false to prevent closure
      */
@@ -258,6 +279,7 @@ export interface RouterOptions {
      */
     root?: string | HTMLElement;
     context?: Record<string | symbol, unknown>;
+    data?: Record<string | symbol, unknown>;
     routes?: RouteConfig[];
     mode?: RouterMode;
     /** Optional in browser, but required on server side */