@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.211

package/src/client/top-loader.tsx

@@ -3,11 +3,11 @@
  *
  * Shows an animated progress bar at the top of the viewport while an RSC
  * navigation is in flight. Injected automatically by the framework into
- * TransitionRoot — users never render this component directly.
+ * NavigationRoot — users never render this component directly.
  *
  * Configuration is via timber.config.ts `topLoader` key. Enabled by default.
  * Users who want a fully custom progress indicator disable the built-in one
- * (`topLoader: { enabled: false }`) and use `useNavigationPending()` directly.
+ * (`topLoader: { enabled: false }`) and use `usePendingNavigation()` directly.
  *
  * Animation approach: pure CSS @keyframes. The bar crawls from 0% to ~90%
  * width over ~30s using ease-out timing. When navigation completes, the bar
@@ -21,14 +21,14 @@
  * stays invisible during the delay period. If navigation finishes before the
  * delay, the bar was never visible so the finish transition is also invisible.
  *
- * See design/19-client-navigation.md §"useNavigationPending()"
+ * See design/19-client-navigation.md §"usePendingNavigation()"
  * See LOCAL-336 for design decisions.
  */
 
 'use client';
 
 import { useState, createElement } from 'react';
-import { usePendingNavigationUrl } from './navigation-context.js';
+import { usePendingNavigation } from './use-pending-navigation.ts';
 
 // ─── Types ───────────────────────────────────────────────────────
 
@@ -39,7 +39,7 @@ export interface TopLoaderConfig {
   color?: string;
   /** Bar height in pixels. Default: 3. */
   height?: number;
-  /** Show subtle glow/shadow effect. Default: true. */
+  /** Show subtle glow/shadow effect. Default: false. */
   shadow?: boolean;
   /** Delay in ms before showing the bar. Default: 0. */
   delay?: number;
@@ -51,7 +51,7 @@ export interface TopLoaderConfig {
 
 const DEFAULT_COLOR = '#2299DD';
 const DEFAULT_HEIGHT = 3;
-const DEFAULT_SHADOW = true;
+const DEFAULT_SHADOW = false;
 const DEFAULT_DELAY = 0;
 const DEFAULT_Z_INDEX = 1600;
 
@@ -97,9 +97,10 @@ function ensureKeyframes(): void {
 // ─── Component ───────────────────────────────────────────────────
 
 /**
- * Internal top-loader component. Injected by TransitionRoot.
+ * Internal top-loader component. Injected by NavigationRoot.
  *
- * Reads pending navigation state from PendingNavigationContext.
+ * Reads pending navigation state from the router's external store, via
+ * usePendingNavigation() — the one pending representation (TIM-1307).
  * Phase transitions are derived synchronously during render:
  *
  *   hidden → crawling:   when isPending becomes true
@@ -111,8 +112,10 @@ function ensureKeyframes(): void {
  * (getDerivedStateFromProps pattern) or triggered by DOM events.
  */
 export function TopLoader({ config }: { config?: TopLoaderConfig }): React.ReactElement | null {
-  const pendingUrl = usePendingNavigationUrl();
-  const isPending = pendingUrl !== null;
+  // Read pending state from the router's external store via
+  // useSyncExternalStore (inside usePendingNavigation). Only this
+  // component re-renders when pending changes — no full-tree re-render.
+  const isPending = usePendingNavigation();
 
   const color = config?.color ?? DEFAULT_COLOR;
   const height = config?.height ?? DEFAULT_HEIGHT;

package/src/client/unload-guard.ts

@@ -8,24 +8,56 @@
  * unloaded so error boundaries and error handlers can suppress abort-related
  * errors during the unload window.
  *
+ * This is the single owner of "is this document going away". Anything that
+ * needs the answer imports `isPageUnloading()` — an unload flag maintained a
+ * second time somewhere else is a flag that will drift out of agreement with
+ * this one (TIM-1260).
+ *
  * Mutable state is delegated to client/state.ts for singleton guarantees.
  * See design/18-build-system.md §"Singleton State Registry"
  *
  * See design/10-error-handling.md §"Known limitation: deny() inside Suspense and hydration"
  */
 
-import { unloading, _setUnloading } from './state.js';
+import { unloading, _setUnloading } from './state.ts';
+
+/**
+ * Departure is *committed*: `pagehide` has fired, or this document has called
+ * reload() on itself. `beforeunload` alone doesn't qualify — it is
+ * speculative, and the user can still cancel out of it.
+ */
+let committed = false;
 
 if (typeof window !== 'undefined') {
   window.addEventListener('beforeunload', () => {
     _setUnloading(true);
+
+    // An app with an unsaved-changes prompt can have this cancelled. Nothing
+    // fires to say so, so the only signal is that the page is still running
+    // afterwards — and timers are blocked while the modal is up, so this task
+    // cannot run until the user has chosen. If they left, `pagehide` has
+    // already committed and this is a no-op.
+    setTimeout(() => {
+      if (!committed) _setUnloading(false);
+    }, 0);
   });
 
-  // Also detect pagehide for bfcache-aware browsers (Safari).
-  // pagehide fires for both navigations and page hide events.
+  // pagehide is the committed-departure event, and fires for both navigations
+  // and bfcache entry. Safari in particular may skip beforeunload entirely.
   window.addEventListener('pagehide', () => {
+    committed = true;
     _setUnloading(true);
   });
+
+  window.addEventListener('pageshow', (event) => {
+    // A bfcache restore un-does the teardown `pagehide` announced: the same
+    // document is alive again, with this module's state intact. Without the
+    // reset, every consumer would go on suppressing errors on a live page.
+    if (event.persisted) {
+      committed = false;
+      _setUnloading(false);
+    }
+  });
 }
 
 /**

package/src/client/use-cookie.ts

@@ -8,8 +8,17 @@
  * See design/29-cookies.md §"useCookie(name) Hook"
  */
 
-import { useSyncExternalStore } from 'react';
-import { getSsrData } from './ssr-data.js';
+// Namespace access, not `import { useSyncExternalStore }`. This module is
+// reachable from `@timber-js/app/cookies` — `defineCookie()` exposes both a
+// server `.get()` and a client `.useCookie()`, so the entry is isomorphic and
+// loads in the RSC environment. React's `react-server` export withholds
+// `useSyncExternalStore` exactly as it withholds `createContext`, and a *named*
+// ESM import of a missing export fails at module instantiation, before any
+// code runs. Same rule as `client/params-context.ts` (TIM-1297, TIM-1298).
+import * as React from 'react';
+import { parseCookie, stringifySetCookie } from 'cookie';
+import { getSsrData } from './ssr-data.ts';
+import { assertValidCookieName } from '../cookies/validation.ts';
 
 // ─── Types ────────────────────────────────────────────────────────────────
 
@@ -38,26 +47,31 @@ type Listener = () => void;
 const listeners = new Map<string, Set<Listener>>();
 
 /** Parse a cookie name from document.cookie. */
-function getCookieValue(name: string): string | undefined {
+export function getCookieValue(name: string): string | undefined {
   if (typeof document === 'undefined') return undefined;
-  const match = document.cookie.match(
-    new RegExp('(?:^|;\\s*)' + name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s*=\\s*([^;]*)')
-  );
-  return match ? decodeURIComponent(match[1]) : undefined;
+  const cookies = parseCookie(document.cookie);
+  return cookies[name];
 }
 
 /** Serialize options into a cookie string suffix. */
-function serializeOptions(options?: ClientCookieOptions): string {
+export function serializeOptions(options?: ClientCookieOptions): string {
   if (!options) return '; Path=/; SameSite=Lax';
-  const parts: string[] = [];
-  parts.push(`Path=${options.path ?? '/'}`);
-  if (options.domain) parts.push(`Domain=${options.domain}`);
-  if (options.maxAge !== undefined) parts.push(`Max-Age=${options.maxAge}`);
-  if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
   const sameSite = options.sameSite ?? 'lax';
-  parts.push(`SameSite=${sameSite.charAt(0).toUpperCase()}${sameSite.slice(1)}`);
-  if (options.secure) parts.push('Secure');
-  return '; ' + parts.join('; ');
+  // Build a Set-Cookie string via the cookie package, then strip the
+  // `__placeholder__=` name=value prefix to get just the attributes.
+  const full = stringifySetCookie({
+    name: '__placeholder__',
+    value: '',
+    path: options.path ?? '/',
+    domain: options.domain,
+    maxAge: options.maxAge,
+    expires: options.expires,
+    sameSite,
+    secure: options.secure,
+  });
+  // Strip everything up to and including the first "; "
+  const idx = full.indexOf('; ');
+  return idx >= 0 ? full.slice(idx) : '';
 }
 
 /** Notify all subscribers for a given cookie name. */
@@ -68,6 +82,17 @@ function notify(name: string): void {
   }
 }
 
+/**
+ * Notify useCookie subscribers that a cookie value changed.
+ * Called by defineCookie's imperative client .set()/.delete() methods
+ * so mounted useCookie() consumers re-render.
+ *
+ * @internal — framework use only
+ */
+export function notifyCookieChange(name: string): void {
+  notify(name);
+}
+
 // ─── Hook ─────────────────────────────────────────────────────────────────
 
 /**
@@ -99,12 +124,39 @@ export function useCookie(
   };
 
   const getSnapshot = (): string | undefined => getCookieValue(name);
-  const getServerSnapshot = (): string | undefined => getSsrData()?.cookies.get(name);
+  const getServerSnapshot = (): string | undefined => {
+    // During SSR, read the ALS-backed request cookies.
+    const ssrData = getSsrData();
+    if (ssrData) return ssrData.cookies.get(name);
+    // During client hydration there is no SSR data (it lives in the server's
+    // module graph), but React still calls getServerSnapshot. document.cookie
+    // holds the same cookies the server rendered with, so reading it here
+    // keeps the hydration render consistent with the server HTML.
+    // See design/29-cookies.md §"SSR Hydration".
+    return getCookieValue(name);
+  };
 
-  const value = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  const value = React.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+
+  // Validate the name once per hook instance — names are typically
+  // stable string literals, so this catches the bug at first render
+  // rather than on every write. Throws via `assertValidCookieName` with
+  // a precise error if the name violates RFC 7230 token rules.
+  assertValidCookieName(name);
 
   const setCookie: CookieSetter = (newValue: string, options?: ClientCookieOptions) => {
+    if (typeof newValue !== 'string') {
+      throw new Error(
+        `[timber] useCookie(${JSON.stringify(name)}): value must be a string, got ${typeof newValue}.\n` +
+          `  To store a JSON-serializable value, use defineCookie + jsonCookieCodec from\n` +
+          `  '@timber-js/app/cookies' and call its useCookie() hook instead.`
+      );
+    }
     const merged = { ...defaultOptions, ...options };
+    // Auto-encode mirrors the server's `cookies().set()` contract:
+    // values are URL-encoded on write, URL-decoded on read, so the
+    // logical bytes round-trip losslessly. See design/29-cookies.md
+    // §"Encoding Contract".
     document.cookie = `${name}=${encodeURIComponent(newValue)}${serializeOptions(merged)}`;
     notify(name);
   };

package/src/client/use-link-status.ts

@@ -1,26 +1,26 @@
 'use client';
 
-// useLinkStatus — returns { pending: true } while the nearest parent <Link>'s
+// useLinkStatus — returns { isPending: true } while the nearest parent <Link>'s
 // navigation is in flight. No arguments — scoped via React context.
 // See design/19-client-navigation.md §"useLinkStatus()"
 
 import { useContext, createContext } from 'react';
 
 export interface LinkStatus {
-  pending: boolean;
+  isPending: boolean;
 }
 
 /**
  * React context provided by <Link>. Holds the pending status
  * for that specific link's navigation.
  */
-export const LinkStatusContext = createContext<LinkStatus>({ pending: false });
+export const LinkStatusContext = createContext<LinkStatus>({ isPending: false });
 
 /**
- * Returns `{ pending: true }` while the nearest parent `<Link>` component's
+ * Returns `{ isPending: true }` while the nearest parent `<Link>` component's
  * navigation is in flight. Must be used inside a `<Link>` component's children.
  *
- * Unlike `useNavigationPending()` which is global, this hook is scoped to
+ * Unlike `usePendingNavigation()` which is global, this hook is scoped to
  * the nearest parent `<Link>` — only the link the user clicked shows pending.
  *
  * ```tsx
@@ -28,8 +28,8 @@ export const LinkStatusContext = createContext<LinkStatus>({ pending: false });
  * import { Link, useLinkStatus } from '@timber-js/app/client'
  *
  * function Hint() {
- *   const { pending } = useLinkStatus()
- *   return <span className={pending ? 'opacity-50' : ''} />
+ *   const { isPending } = useLinkStatus()
+ *   return <span className={isPending ? 'opacity-50' : ''} />
  * }
  *
  * export function NavLink({ href, children }) {

package/src/client/use-pathname.ts

@@ -4,47 +4,38 @@
  * Returns the pathname portion of the current URL (e.g. '/dashboard/settings').
  * Updates when client-side navigation changes the URL.
  *
- * On the client, reads from NavigationContext which is updated atomically
- * with the RSC tree render. This replaces the previous useSyncExternalStore
- * approach which only subscribed to popstate events — meaning usePathname()
- * did NOT re-render on forward navigation (pushState). The context approach
- * fixes this: pathname updates in the same render pass as the new tree.
+ * One unconditional read of NavigationContext, on every side (TIM-1425):
  *
- * During SSR, reads the request pathname from the SSR ALS context
- * (populated by ssr-entry.ts) instead of window.location.
+ * - In the browser, the provider wraps the RSC payload in the router's `renderTree`, so
+ *   the pathname updates in the same render pass as the new tree.
+ * - During SSR, the wrapper chain mounts the same provider with the request's
+ *   pathname (TIM-1424), so this is the identical code path — no ALS read,
+ *   no fallback tiers.
+ * - In the RSC environment, this module is never evaluated — the shims plugin
+ *   resolves next/navigation to navigation-rsc.ts, which has a throwing stub
+ *   (TIM-1420).
+ * - Called outside a component entirely, React itself throws its
+ *   invalid-hook-call error — loud, not guessed-at from window.location.
  *
  * Compatible with Next.js's `usePathname()` from `next/navigation`.
  */
 
-import { getSsrData } from './ssr-data.js';
-import { useNavigationContext } from './navigation-context.js';
+import { useNavigationContext } from './navigation-context.ts';
 
 /**
  * Read the current URL pathname.
  *
- * On the client, reads from NavigationContext (provided by
- * NavigationProvider in renderRoot). During SSR, reads from the
- * ALS-backed SSR data context. Falls back to window.location.pathname
- * when called outside a React component (e.g., in tests).
+ * Throws when no NavigationProvider is above the caller (a component rendered
+ * outside the timber app — in tests, render inside the timber providers).
  */
 export function usePathname(): string {
-  // Try reading from NavigationContext (client-side, inside React tree).
-  // During SSR, no NavigationProvider is mounted, so this returns null.
-  try {
-    const navContext = useNavigationContext();
-    if (navContext !== null) {
-      return navContext.pathname;
-    }
-  } catch {
-    // No React dispatcher available (called outside a component).
-    // Fall through to SSR/fallback below.
+  const nav = useNavigationContext();
+  if (nav === null) {
+    throw new Error(
+      '[timber] usePathname() was called outside the timber app tree ' +
+        '(no NavigationProvider found). In tests, render the component ' +
+        'inside the timber providers.'
+    );
   }
-
-  // SSR path: read from ALS-backed SSR data context.
-  const ssrData = getSsrData();
-  if (ssrData) return ssrData.pathname ?? '/';
-
-  // Final fallback: window.location (tests, edge cases).
-  if (typeof window !== 'undefined') return window.location.pathname;
-  return '/';
+  return nav.pathname;
 }

package/src/client/use-pending-navigation.ts

@@ -0,0 +1,40 @@
+import { useSyncExternalStore } from 'react';
+import { getRouterOrNull } from './router-ref.ts';
+
+function subscribe(onStoreChange: () => void): () => void {
+  const router = getRouterOrNull();
+  if (!router) return () => {};
+  return router.onPendingChange(onStoreChange);
+}
+
+function getSnapshot(): boolean {
+  const router = getRouterOrNull();
+  return router ? router.isPending() : false;
+}
+
+const getServerSnapshot = getSnapshot;
+
+/**
+ * Returns true while an RSC navigation is in flight.
+ *
+ * Reads from the router's external pending store via useSyncExternalStore.
+ * Only components that call this hook re-render when pending state
+ * changes — no full-tree re-render.
+ *
+ * ```tsx
+ * 'use client'
+ * import { usePendingNavigation } from '@timber-js/app/client'
+ *
+ * export function NavBar() {
+ *   const isPending = usePendingNavigation()
+ *   return (
+ *     <nav className={isPending ? 'opacity-50' : ''}>
+ *       <Link href="/dashboard">Dashboard</Link>
+ *     </nav>
+ *   )
+ * }
+ * ```
+ */
+export function usePendingNavigation(): boolean {
+  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}