@timber-js/app 0.2.0-alpha.18 → 0.2.0-alpha.181

package/src/client/navigation-api.ts

@@ -0,0 +1,345 @@
+/**
+ * Navigation API integration — progressive enhancement for client navigation.
+ *
+ * When the Navigation API (`window.navigation`) is available, this module
+ * provides an intercept-based navigation model that replaces the separate
+ * popstate + click handler approach with a single navigate event listener.
+ *
+ * Key benefits:
+ * - Intercepts ALL navigations (link clicks, form submissions, back/forward)
+ * - Built-in AbortSignal per navigation (auto-aborts in-flight fetches)
+ * - Per-entry state via NavigationHistoryEntry.getState()
+ * - navigation.transition for progress tracking
+ *
+ * When unavailable, all functions are no-ops and the History API fallback
+ * in browser-entry.ts handles navigation.
+ *
+ * See design/19-client-navigation.md
+ */
+
+import { isHardNavigating } from './navigation-root.js';
+
+// ─── Feature Detection ───────────────────────────────────────────
+
+/**
+ * Returns true if the Navigation API is available in the current environment.
+ * Feature-detected at runtime — no polyfill.
+ */
+export function hasNavigationApi(): boolean {
+  return typeof window !== 'undefined' && 'navigation' in window && window.navigation != null;
+}
+
+/**
+ * Get the Navigation API instance. Returns null if unavailable.
+ */
+export function getNavigationApi(): Navigation | null {
+  if (!hasNavigationApi()) return null;
+  return window.navigation;
+}
+
+// ─── Navigation API Controller ───────────────────────────────────
+
+/**
+ * Callbacks for the Navigation API event handler.
+ *
+ * When the Navigation API intercepts a navigation, it delegates to these
+ * callbacks which run the RSC fetch + render pipeline.
+ */
+export interface NavigationApiCallbacks {
+  /**
+   * Handle a push/replace navigation intercepted by the Navigation API.
+   * This covers both Link <a> clicks (user-initiated) and external
+   * navigations (plain <a> tags, programmatic).
+   * The Navigation API handles the URL update via event.intercept().
+   */
+  onExternalNavigate: (
+    url: string,
+    options: { replace: boolean; signal: AbortSignal; scroll?: boolean; departingUrl?: string }
+  ) => Promise<void>;
+
+  /**
+   * Handle a traversal (back/forward button). The Navigation API intercepts
+   * the traversal and delegates to us for RSC replay/fetch.
+   */
+  onTraverse: (url: string, scrollY: number, signal: AbortSignal) => Promise<void>;
+
+  /**
+   * Called when a shallow URL update is intercepted (e.g., nuqs with
+   * shallow: true, or replaceUrl). The URL has already been committed —
+   * this callback syncs NavigationContext.search so useSearchParams()
+   * reflects the new value without a full router navigation.
+   */
+  onShallowNavigate?: (url: string) => void;
+}
+
+/**
+ * Controller returned by setupNavigationApi. Provides methods to
+ * coordinate between the router and the navigate event listener.
+ */
+export interface NavigationApiController {
+  /**
+   * Set the router-navigating flag. When `true`, the next navigate event
+   * (from pushState/replaceState) is recognized as router-initiated. The
+   * handler still intercepts it — but ties the browser's native loading
+   * state to a deferred promise instead of running the RSC pipeline again.
+   *
+   * This means `navigation.transition` is active for the full duration of
+   * every router-initiated navigation, giving the browser a native loading
+   * indicator (tab spinner, address bar) aligned with the TopLoader.
+   *
+   * Must be called synchronously around pushState/replaceState:
+   *   controller.setRouterNavigating(true);
+   *   history.pushState(...);        // navigate event fires, intercepted
+   *   controller.setRouterNavigating(false);  // flag off, deferred stays open
+   */
+  setRouterNavigating: (value: boolean) => void;
+
+  /**
+   * Resolve the deferred promise created by setRouterNavigating(true),
+   * clearing the browser's native loading state. Call this when the
+   * navigation fully completes — aligned with when the TopLoader's
+   * pendingUrl clears (same finally block in router.navigate).
+   */
+  completeRouterNavigation: () => void;
+
+  /**
+   * Initiate a navigation via the Navigation API (`navigation.navigate()`).
+   * Unlike `history.pushState()`, this fires the navigate event BEFORE
+   * committing the URL — allowing Chrome to show its native loading
+   * indicator while the intercept handler runs.
+   *
+   * Must be called with setRouterNavigating(true) active so the handler
+   * recognizes it as router-initiated and uses the deferred promise.
+   */
+  navigate: (url: string, replace: boolean) => void;
+
+  /**
+   * Save scroll position into the current navigation entry's state.
+   * Uses navigation.updateCurrentEntry() for per-entry scroll storage.
+   */
+  saveScrollPosition: (scrollY: number) => void;
+
+  /**
+   * Check if the Navigation API has an active transition.
+   * Returns the transition object if available, null otherwise.
+   */
+  hasActiveTransition: () => boolean;
+
+  /** Remove the navigate event listener. */
+  cleanup: () => void;
+}
+
+/**
+ * Set up the Navigation API navigate event listener.
+ *
+ * Intercepts same-origin navigations and delegates to the provided callbacks.
+ * Router-initiated navigations (pushState from router.navigate) are detected
+ * via a synchronous flag and NOT intercepted — the router already handles them.
+ *
+ * Returns a controller for coordinating with the router.
+ */
+export function setupNavigationApi(callbacks: NavigationApiCallbacks): NavigationApiController {
+  const nav = getNavigationApi()!;
+
+  let routerNavigating = false;
+
+  // Deferred promise for router-initiated navigations. Created when
+  // setRouterNavigating(true) is called, resolved by completeRouterNavigation().
+  // The navigate event handler intercepts with this promise so the browser's
+  // native loading state (tab spinner) stays active until the navigation
+  // completes — aligned with TopLoader's pendingUrl lifecycle.
+  let routerNavDeferred: { promise: Promise<void>; resolve: () => void } | null = null;
+
+  function handleNavigate(event: NavigateEvent): void {
+    // Skip non-interceptable navigations (cross-origin, etc.)
+    if (!event.canIntercept) return;
+
+    // Hard navigation guard: when the router has triggered a full page
+    // load (500 error, version skew), skip interception entirely so the
+    // browser performs the MPA navigation. Without this guard, setting
+    // window.location.href fires a navigate event that we'd intercept,
+    // running the RSC pipeline again → 500 → window.location.href →
+    // navigate event → infinite loop.
+    // See design/19-client-navigation.md §"Hard Navigation Guard"
+    if (isHardNavigating()) return;
+
+    // Skip download requests
+    if (event.downloadRequest) return;
+
+    // Skip blob: URLs — these are almost always downloads or object-URL
+    // navigations initiated by the host page (e.g., generated files, PDFs).
+    // The RSC pipeline cannot handle them, and intercepting would break
+    // the download/open behavior the host page expects.
+    if (event.destination.url.startsWith('blob:')) return;
+
+    // Skip hash-only changes — let the browser handle scroll-to-anchor
+    if (event.hashChange) return;
+
+    // Shallow URL updates (e.g., nuqs search param changes). The navigation
+    // only changes the URL — no server round trip needed. Intercept with a
+    // no-op handler so the Navigation API commits the URL change without
+    // triggering a full page navigation (which is the default if we don't
+    // intercept). The info property is the Navigation API's built-in
+    // per-navigation metadata — no side-channel flags needed.
+    const info = event.info as { shallow?: boolean } | null | undefined;
+    if (info?.shallow) {
+      event.intercept({
+        handler: () => Promise.resolve(),
+        focusReset: 'manual',
+        scroll: 'manual',
+      });
+      callbacks.onShallowNavigate?.(event.destination.url);
+      return;
+    }
+
+    // Skip form submissions with a body (POST/PUT/etc.). These need the
+    // browser's native form handling to send the request body to the server.
+    // Intercepting would convert them into GET RSC navigations, dropping
+    // the form data. Server actions use fetch() directly (not form navigation),
+    // so they are unaffected by this check.
+    if (event.formData) return;
+
+    // Skip cross-origin (defense-in-depth — canIntercept covers this)
+    const destUrl = new URL(event.destination.url);
+    if (destUrl.origin !== location.origin) return;
+
+    // Router-initiated navigation (Link click → router.navigate → pushState).
+    // The router is already running the RSC pipeline — don't run it again.
+    // Instead, intercept with the deferred promise so the browser's native
+    // loading state tracks the navigation's full lifecycle. This aligns the
+    // tab spinner / address bar indicator with the TopLoader.
+    if (routerNavigating && routerNavDeferred) {
+      event.intercept({
+        scroll: 'manual',
+        focusReset: 'manual',
+        handler: () => routerNavDeferred!.promise,
+      });
+      return;
+    }
+
+    // Skip reload navigations — let the browser handle full page reload
+    if (event.navigationType === 'reload') return;
+
+    const url = destUrl.pathname + destUrl.search;
+
+    if (event.navigationType === 'traverse') {
+      // Back/forward button — intercept and delegate to router.
+      // Read scroll position from the destination entry's state.
+      const entryState = event.destination.getState() as
+        | { scrollY?: number; timber?: boolean }
+        | null
+        | undefined;
+      const scrollY = entryState && typeof entryState.scrollY === 'number' ? entryState.scrollY : 0;
+
+      event.intercept({
+        // Manual scroll — we handle scroll restoration ourselves
+        // via afterPaint (same as the History API path).
+        scroll: 'manual',
+        focusReset: 'manual',
+        async handler() {
+          await callbacks.onTraverse(url, scrollY, event.signal);
+        },
+      });
+    } else if (event.navigationType === 'push' || event.navigationType === 'replace') {
+      // Push/replace — a Link <a> click or an external navigation
+      // (plain <a> tag, programmatic).
+
+      // Save the departing page's scroll position BEFORE event.intercept()
+      // commits the URL change. Once intercept() is called, currentEntry
+      // switches to the new (destination) entry — any updateCurrentEntry()
+      // call after that would save to the wrong entry.
+      // See: router.navigate() also calls saveNavigationEntryScroll(), but
+      // for Navigation API <a> click navigations (where Link does NOT call
+      // router.navigate directly), the router's save runs inside the
+      // intercept handler — too late, currentEntry has already switched.
+      try {
+        const currentState = (nav.currentEntry?.getState() ?? {}) as Record<string, unknown>;
+        nav.updateCurrentEntry({
+          state: { ...currentState, timber: true, scrollY: window.scrollY },
+        });
+      } catch {
+        // Ignore — entry may be disposed
+      }
+
+      // Capture the departing URL BEFORE event.intercept() commits the
+      // destination. Once intercept() is called, currentEntry switches and
+      // getCurrentUrl() returns the destination (TIM-1232).
+      const departingUrl = nav.currentEntry?.url
+        ? new URL(nav.currentEntry.url).pathname + new URL(nav.currentEntry.url).search
+        : undefined;
+
+      event.intercept({
+        scroll: 'manual',
+        focusReset: 'manual',
+        async handler() {
+          await callbacks.onExternalNavigate(url + destUrl.hash, {
+            replace: event.navigationType === 'replace',
+            signal: event.signal,
+            scroll: undefined,
+            departingUrl,
+          });
+        },
+      });
+    }
+  }
+
+  nav.addEventListener('navigate', handleNavigate);
+
+  return {
+    setRouterNavigating(value: boolean): void {
+      routerNavigating = value;
+      if (value) {
+        // Create a new deferred promise. The navigate event handler will
+        // intercept and tie the browser's loading state to this promise.
+        let resolve!: () => void;
+        const promise = new Promise<void>((r) => {
+          resolve = r;
+        });
+        routerNavDeferred = { promise, resolve };
+      } else {
+        // Flag off — but DON'T resolve the deferred here. The navigation
+        // is still in flight (RSC fetch + render). completeRouterNavigation()
+        // resolves it when the navigation fully completes.
+        routerNavigating = false;
+      }
+    },
+
+    completeRouterNavigation(): void {
+      if (routerNavDeferred) {
+        routerNavDeferred.resolve();
+        routerNavDeferred = null;
+      }
+    },
+
+    navigate(url: string, replace: boolean): void {
+      // Use navigation.navigate() instead of history.pushState().
+      // This fires the navigate event BEFORE committing the URL,
+      // which lets Chrome show its native loading indicator while
+      // the intercept handler (deferred promise) is pending.
+      // history.pushState() commits the URL synchronously, so Chrome
+      // sees the navigation as already complete and skips the indicator.
+      nav.navigate(url, {
+        history: replace ? 'replace' : 'push',
+      });
+    },
+
+    saveScrollPosition(scrollY: number): void {
+      try {
+        const currentState = (nav.currentEntry?.getState() ?? {}) as Record<string, unknown>;
+        nav.updateCurrentEntry({
+          state: { ...currentState, timber: true, scrollY },
+        });
+      } catch {
+        // Ignore errors — updateCurrentEntry may throw if entry is disposed
+      }
+    },
+
+    hasActiveTransition(): boolean {
+      return nav.transition != null;
+    },
+
+    cleanup(): void {
+      nav.removeEventListener('navigate', handleNavigate);
+    },
+  };
+}

package/src/client/navigation-context.ts

@@ -5,7 +5,7 @@
  *
  * Holds the current route params and pathname, updated atomically
  * with the RSC tree on each navigation. This replaces the previous
- * useSyncExternalStore approach for useParams() and usePathname(),
+ * useSyncExternalStore approach for useSegmentParams() and usePathname(),
  * which suffered from a timing gap: the new tree could commit before
  * the external store re-renders fired, causing a frame where both
  * old and new active states were visible simultaneously.
@@ -48,6 +48,7 @@ import React, { createElement, type ReactNode } from 'react';
 export interface NavigationState {
   params: Record<string, string | string[]>;
   pathname: string;
+  search: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -62,11 +63,15 @@ export interface NavigationState {
  * Context instances are stored on globalThis (NOT in module-level
  * variables) because the ESM bundler can duplicate this module across
  * chunks. Module-level variables would create separate instances per
- * chunk — the provider in TransitionRoot (index chunk) would use
- * context A while the consumer in LinkStatusProvider (shared chunk)
+ * chunk — the provider in NavigationRoot (index chunk) would use
+ * context A while the consumer in usePendingNavigation (shared chunk)
  * reads from context B. globalThis guarantees a single instance.
  *
  * See design/27-chunking-strategy.md §"Singleton Safety"
+ *
+ * NOTE: Despite similar naming, `usePendingNavigationUrl()` here is an
+ * internal helper — the public hook is `usePendingNavigation()` in
+ * use-pending-navigation.ts.
  */
 
 // Symbol keys for globalThis storage — prevents collisions with user code
@@ -90,13 +95,14 @@ function getOrCreateContext(): React.Context<NavigationState | null> | undefined
 /**
  * Read the navigation context. Returns null during SSR (no provider)
  * or in the RSC environment (no context available).
- * Internal — used by useParams() and usePathname().
+ * Internal — used by useSegmentParams() and usePathname().
  */
 export function useNavigationContext(): NavigationState | null {
   const ctx = getOrCreateContext();
   if (!ctx) return null;
   // useContext may not exist in the RSC environment — caller wraps in try/catch
   if (typeof React.useContext !== 'function') return null;
+  // eslint-disable-next-line rules-of-hooks -- conditional on environment, not render path
   return React.useContext(ctx);
 }
 
@@ -149,7 +155,7 @@ const NAV_STATE_KEY = Symbol.for('__timber_nav_state');
 function _getNavStateStore(): { current: NavigationState } {
   const g = globalThis as Record<symbol, unknown>;
   if (!g[NAV_STATE_KEY]) {
-    g[NAV_STATE_KEY] = { current: { params: {}, pathname: '/' } };
+    g[NAV_STATE_KEY] = { current: { params: {}, pathname: '/', search: '' } };
   }
   return g[NAV_STATE_KEY] as { current: NavigationState };
 }
@@ -168,8 +174,9 @@ export function getNavigationState(): NavigationState {
 
 /**
  * Separate context for the in-flight navigation URL. Provided by
- * TransitionRoot (urgent useState), consumed by LinkStatusProvider
- * and useNavigationPending.
+ * NavigationRoot (urgent useState), consumed by usePendingNavigation
+ * and TopLoader. Per-link pending state uses useOptimistic instead
+ * (see design/19-client-navigation.md §"Per-Link Pending State").
  *
  * Uses globalThis via Symbol.for for the same reason as NavigationContext
  * above — the bundler may duplicate this module across chunks, and module-
@@ -197,6 +204,7 @@ export function usePendingNavigationUrl(): string | null {
   const ctx = getOrCreatePendingContext();
   if (!ctx) return null;
   if (typeof React.useContext !== 'function') return null;
+  // eslint-disable-next-line react-hooks/rules-of-hooks -- conditional on environment, not render path
   return React.useContext(ctx);
 }