@rangojs/router 0.0.0-experimental.002d056c

package/src/browser/react/location-state-shared.ts

@@ -0,0 +1,162 @@
+/**
+ * Shared location state utilities - works in both RSC and client contexts
+ * No "use client" directive so it can be imported from RSC
+ */
+
+/**
+ * Internal entry representing a state value with its unique key.
+ * When __rsc_ls_lazy is true, __rsc_ls_value holds a getter function
+ * that is called at navigation time (not at entry creation time).
+ */
+export interface LocationStateEntry {
+  readonly __rsc_ls_key: string;
+  readonly __rsc_ls_value: unknown;
+  readonly __rsc_ls_lazy?: boolean;
+}
+
+/**
+ * Options for createLocationState
+ */
+export interface LocationStateOptions {
+  /** When true, the state is cleared from history after first read (flash message pattern) */
+  flash?: boolean;
+}
+
+/**
+ * Type-safe location state definition
+ *
+ * Created via createLocationState(), used with Link's state prop
+ * and useLocationState() hook.
+ */
+export interface LocationStateDefinition<TArgs extends unknown[], TState> {
+  (...args: TArgs): LocationStateEntry;
+  /** Injected by Vite plugin - do not set manually */
+  __rsc_ls_key: string;
+  /** Whether this state auto-clears after first read */
+  readonly __rsc_ls_flash: boolean;
+  /** Read the current value from history.state (client-side only, undefined during SSR) */
+  read(): TState | undefined;
+}
+
+/**
+ * Create a type-safe location state definition
+ *
+ * The key is auto-injected by the Vite exposeInternalIds plugin as a property
+ * based on file path and export name. No manual key required.
+ *
+ * @param options Optional configuration
+ * @returns A typed state definition for use with Link and useLocationState
+ *
+ * @example
+ * ```typescript
+ * // Persistent state (survives back/forward)
+ * export const ProductState = createLocationState<{ name: string; price: number }>();
+ *
+ * // Flash state (cleared after first read)
+ * export const FlashMessage = createLocationState<{ text: string }>({ flash: true });
+ *
+ * // Use in Link
+ * <Link to="/product/123" state={[ProductState({ name: "Widget", price: 9.99 })]}>
+ *
+ * // Just-in-time typed state (getter called at click time, not render time).
+ * // Must be in a client component — the getter function can't cross the RSC boundary.
+ * <Link
+ *   to="/product/123"
+ *   state={[ProductState(() => ({ name: product.name, price: product.price }))]}
+ * >
+ *
+ * // Read with hook (reactive)
+ * const product = useLocationState(ProductState);
+ *
+ * // Read without hook (snapshot, client-side only)
+ * const snap = ProductState.read();
+ * ```
+ */
+export function createLocationState<TState>(
+  options?: LocationStateOptions,
+): LocationStateDefinition<[TState | (() => TState)], TState> {
+  const flash = options?.flash ?? false;
+  let _key: string | undefined;
+
+  function getKey(): string {
+    if (!_key && process.env.NODE_ENV === "development") {
+      throw new Error(
+        "[rsc-router] createLocationState key not set. " +
+          "Make sure the exposeInternalIds Vite plugin is enabled and " +
+          "the state is exported with: export const MyState = createLocationState(...)",
+      );
+    }
+    return _key!;
+  }
+
+  const fn = (stateOrGetter: TState | (() => TState)): LocationStateEntry => {
+    if (typeof stateOrGetter === "function") {
+      // Store getter as-is; resolved at navigation time by resolveLocationStateEntries()
+      return {
+        __rsc_ls_key: getKey(),
+        __rsc_ls_value: stateOrGetter,
+        __rsc_ls_lazy: true,
+      };
+    }
+    return {
+      __rsc_ls_key: getKey(),
+      __rsc_ls_value: stateOrGetter,
+    };
+  };
+
+  // Use defineProperty for __rsc_ls_key to avoid Object.assign evaluating
+  // the getter during construction (before the Vite plugin sets the key).
+  Object.defineProperty(fn, "__rsc_ls_key", {
+    get: () => getKey(),
+    set: (k: string) => {
+      _key = k;
+    },
+    enumerable: true,
+    configurable: true,
+  });
+
+  Object.defineProperty(fn, "__rsc_ls_flash", {
+    value: flash,
+    enumerable: true,
+  });
+
+  Object.defineProperty(fn, "read", {
+    value: (): TState | undefined => {
+      if (typeof window === "undefined") return undefined;
+      return window.history.state?.[getKey()] as TState | undefined;
+    },
+    enumerable: true,
+  });
+
+  return fn as LocationStateDefinition<[TState | (() => TState)], TState>;
+}
+
+/**
+ * Check if a value is a LocationStateEntry
+ */
+export function isLocationStateEntry(
+  value: unknown,
+): value is LocationStateEntry {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    "__rsc_ls_key" in value &&
+    "__rsc_ls_value" in value &&
+    typeof (value as LocationStateEntry).__rsc_ls_key === "string"
+  );
+}
+
+/**
+ * Resolve state entries into a flat object for history.state
+ */
+export function resolveLocationStateEntries(
+  entries: LocationStateEntry[],
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const entry of entries) {
+    result[entry.__rsc_ls_key] = entry.__rsc_ls_lazy
+      ? (entry.__rsc_ls_value as () => unknown)()
+      : entry.__rsc_ls_value;
+  }
+  return result;
+}

package/src/browser/react/location-state.ts

@@ -0,0 +1,107 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import type { LocationStateDefinition } from "./location-state-shared.js";
+
+// Re-export shared utilities and types
+export {
+  createLocationState,
+  isLocationStateEntry,
+  resolveLocationStateEntries,
+  type LocationStateEntry,
+  type LocationStateDefinition,
+  type LocationStateOptions,
+} from "./location-state-shared.js";
+
+/**
+ * Hook to read location state from history.state
+ *
+ * Behavior depends on the definition:
+ * - Normal state: persists across navigations, reactive to popstate
+ * - Flash state (created with { flash: true }): read once, cleared after paint
+ *
+ * Overloaded:
+ * - With definition: Returns typed state from the specific key
+ * - With type param only: Returns plain state from history.state.state
+ *
+ * @example
+ * ```typescript
+ * // Persistent state
+ * const ProductState = createLocationState<{ name: string }>();
+ * const state = useLocationState(ProductState);
+ *
+ * // Flash state (auto-clears after paint)
+ * const FlashMsg = createLocationState<{ text: string }>({ flash: true });
+ * const flash = useLocationState(FlashMsg);
+ *
+ * // Plain state access (reads from history.state.state)
+ * const state = useLocationState<{ from?: string }>();
+ * ```
+ */
+export function useLocationState<TArgs extends unknown[], TState>(
+  definition: LocationStateDefinition<TArgs, TState>,
+): TState | undefined;
+export function useLocationState<T = unknown>(): T | undefined;
+export function useLocationState<TArgs extends unknown[], TState>(
+  definition?: LocationStateDefinition<TArgs, TState>,
+): TState | undefined {
+  const key = definition?.__rsc_ls_key;
+  const isFlash = definition?.__rsc_ls_flash ?? false;
+
+  const [state, setState] = useState<TState | undefined>(() => {
+    if (typeof window === "undefined") return undefined;
+    if (key) {
+      return window.history.state?.[key] as TState | undefined;
+    }
+    // Plain state: stored under history.state.state
+    return window.history.state?.state as TState | undefined;
+  });
+
+  // Subscribe to popstate and programmatic state changes
+  useEffect(() => {
+    const handlePopstate = () => {
+      if (key) {
+        setState(window.history.state?.[key] as TState | undefined);
+      } else {
+        setState(window.history.state?.state as TState | undefined);
+      }
+    };
+
+    // Handle programmatic state changes (same-page navigation with
+    // ctx.setLocationState where components don't remount)
+    const handleLocationState = () => {
+      if (key) {
+        const val = window.history.state?.[key] as TState | undefined;
+        if (isFlash) {
+          // For flash state, only update if there's a new value
+          if (val !== undefined) {
+            setState(val);
+          }
+        } else {
+          setState(val);
+        }
+      } else {
+        setState(window.history.state?.state as TState | undefined);
+      }
+    };
+
+    window.addEventListener("popstate", handlePopstate);
+    window.addEventListener("__rsc_locationstate", handleLocationState);
+    return () => {
+      window.removeEventListener("popstate", handlePopstate);
+      window.removeEventListener("__rsc_locationstate", handleLocationState);
+    };
+  }, [key, isFlash]);
+
+  // Flash: clear from history.state after paint so subsequent navigations don't see it.
+  // Depends on `state` so it re-runs when state is set via the event listener.
+  useEffect(() => {
+    if (isFlash && key && state !== undefined) {
+      const cleaned = { ...window.history.state };
+      delete cleaned[key];
+      window.history.replaceState(cleaned, "", window.location.href);
+    }
+  }, [isFlash, key, state]);
+
+  return state;
+}

package/src/browser/react/mount-context.ts

@@ -0,0 +1,37 @@
+"use client";
+
+import {
+  createContext,
+  createElement,
+  type Context,
+  type ReactNode,
+} from "react";
+
+/**
+ * Context for the current include() mount path.
+ *
+ * Each include() wraps its subtree with a MountContext.Provider
+ * carrying the URL prefix. Nested includes override the context,
+ * so useMount() returns the nearest mount path.
+ *
+ * Default value "/" means root-level (no include wrapping).
+ */
+export const MountContext: Context<string> = createContext<string>("/");
+
+/**
+ * Provider wrapper for MountContext.
+ *
+ * RSC server components cannot use MountContext.Provider directly because
+ * .Provider is a property on the context object, not a named export.
+ * Client reference proxies on the RSC server return undefined for property
+ * access. This wrapper is a proper "use client" export that RSC can reference.
+ */
+export function MountContextProvider({
+  value,
+  children,
+}: {
+  value: string;
+  children: ReactNode;
+}): ReactNode {
+  return createElement(MountContext, { value }, children);
+}

package/src/browser/react/nonce-context.ts

@@ -0,0 +1,23 @@
+"use client";
+
+/**
+ * Context for CSP nonce propagation to client components during SSR.
+ *
+ * The SSR renderer wraps the tree with NonceContext.Provider so that
+ * client components (e.g. MetaTags) can apply nonces to inline scripts.
+ * On the browser side, no provider is needed — the default undefined
+ * is correct since CSP nonces are a server-side HTML concern.
+ */
+
+import { createContext, useContext, type Context } from "react";
+
+export const NonceContext: Context<string | undefined> = createContext<
+  string | undefined
+>(undefined);
+
+/**
+ * Read the CSP nonce during SSR. Returns undefined on the client.
+ */
+export function useNonce(): string | undefined {
+  return useContext(NonceContext);
+}

package/src/browser/react/shallow-equal.ts

@@ -0,0 +1,27 @@
+/**
+ * Shallow equality check for selector results.
+ * Uses Object.is for value comparison (handles NaN and +-0 correctly).
+ */
+export function shallowEqual<T>(a: T, b: T): boolean {
+  if (Object.is(a, b)) return true;
+  if (
+    typeof a !== "object" ||
+    a === null ||
+    typeof b !== "object" ||
+    b === null
+  ) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (
+      !Object.hasOwn(b, key) ||
+      !Object.is((a as any)[key], (b as any)[key])
+    ) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/browser/react/use-action.ts

@@ -0,0 +1,218 @@
+"use client";
+
+import {
+  useContext,
+  useState,
+  useEffect,
+  useRef,
+  useOptimistic,
+  startTransition,
+} from "react";
+import { NavigationStoreContext } from "./context.js";
+import { shallowEqual } from "./shallow-equal.js";
+import type { TrackedActionState } from "../types.js";
+import { invariant } from "../../errors.js";
+
+/**
+ * Default action state (idle with no payload)
+ */
+const DEFAULT_ACTION_STATE: TrackedActionState = {
+  state: "idle",
+  actionId: null,
+  payload: null,
+  error: null,
+  result: null,
+};
+
+/**
+ * Normalize action ID - returns the ID as-is
+ *
+ * Server actions have IDs like "hash#actionName" or "src/actions.ts#actionName".
+ * When using function references, we use the full ID for exact matching.
+ * When using strings, the event controller supports suffix matching
+ * (e.g., "addToCart" matches "hash#addToCart").
+ */
+function normalizeActionId(actionId: string): string {
+  return actionId;
+}
+
+/**
+ * Extract action ID from a server action function or string.
+ *
+ * Actions passed as props from server components lose their metadata
+ * during RSC serialization - use a string action name instead.
+ */
+export function getActionId(action: ServerActionFunction | string): string {
+  invariant(
+    typeof action === "function" || typeof action === "string",
+    `useAction: action must be a function or string, got ${typeof action}`,
+  );
+  const actionId = (action as any)?.$$id;
+  if (actionId) {
+    return normalizeActionId(actionId);
+  }
+
+  // If action is a string, use it directly
+  if (typeof action === "string") {
+    return action;
+  }
+
+  // If we get here, this is likely an action passed as prop from a server component
+  // These lose their metadata during RSC serialization
+  throw new Error(
+    `useAction: Cannot extract action ID from function reference.
+
+This typically happens when an action is passed as a prop from a server component.
+Actions passed through RSC lose their metadata during serialization.
+
+Solutions:
+1. Import the action directly in your client component:
+   import { myAction } from './actions';
+   const state = useAction(myAction);
+
+2. Use the action name as a string:
+   const state = useAction("myAction");
+
+The string must match the exported function name from your "use server" file.`,
+  );
+}
+
+/**
+ * Server action function type
+ * Server actions have a $$id property added by the RSC compiler
+ */
+export type ServerActionFunction = ((...args: any[]) => Promise<any>) & {
+  $$id?: string;
+};
+
+/**
+ * Hook to track the lifecycle of a specific server action
+ *
+ * Unlike useNavigation which tracks global navigation state, useAction
+ * tracks the state of individual server action invocations.
+ *
+ * Uses the event controller for reactive state management.
+ * State is derived from the inflight actions tracked by the controller.
+ *
+ * Features:
+ * - Tracks action lifecycle: idle → loading → streaming → idle
+ * - Captures result/error locally (React handles cleanup)
+ * - If multiple actions fire, tracks only the last one
+ * - Supports selector pattern like useNavigation
+ *
+ * Matching behavior:
+ * - **Function reference**: Uses full $$id for exact matching. This is precise
+ *   and distinguishes between actions with the same name in different files.
+ * - **String**: Matches by suffix (action name after #). This is convenient
+ *   but may be ambiguous if multiple files export the same action name.
+ *
+ * @param action - Either a server action function or a string action name.
+ *   - **Function**: Must be directly imported in the client component.
+ *     Actions passed as props from server components will throw an error.
+ *   - **String**: The exported function name from your "use server" file.
+ *     Matches any action ending with "#actionName" (suffix match).
+ *
+ * @example
+ * ```tsx
+ * // Option 1: Direct import (precise matching)
+ * import { addToCart } from './actions';
+ * const actionState = useAction(addToCart);
+ *
+ * // Option 2: String-based (suffix matching)
+ * // Matches "hash#addToCart" or "src/actions.ts#addToCart"
+ * const actionState = useAction('addToCart');
+ *
+ * // With selector for specific values
+ * const isLoading = useAction(addToCart, state => state.state === 'loading');
+ * const error = useAction(addToCart, state => state.error);
+ * ```
+ *
+ * @note The selector is expected to be stable for a given hook instance.
+ * This hook tracks one projection of one action. Changing selector semantics
+ * for the same action ID without a new action event is not a supported pattern;
+ * use separate useAction() subscriptions if you need different projections.
+ *
+ * @note Actions passed as props from server components lose their metadata
+ * during RSC serialization. Use a string action name or import directly.
+ */
+export function useAction(
+  action: ServerActionFunction | string,
+): TrackedActionState;
+export function useAction<T>(
+  action: ServerActionFunction | string,
+  selector: (state: TrackedActionState) => T,
+): T;
+export function useAction<T>(
+  action: ServerActionFunction | string,
+  selector?: (state: TrackedActionState) => T,
+): T | TrackedActionState {
+  const ctx = useContext(NavigationStoreContext);
+  const actionId =
+    typeof window !== "undefined" && typeof document !== "undefined"
+      ? getActionId(action)
+      : "";
+
+  // Base state for useOptimistic
+  const [baseState, setBaseState] = useState<T | TrackedActionState>(() => {
+    if (!ctx) {
+      return selector ? selector(DEFAULT_ACTION_STATE) : DEFAULT_ACTION_STATE;
+    }
+    const state = ctx.eventController.getActionState(actionId);
+    return selector ? selector(state) : state;
+  });
+  const prevSelected = useRef(baseState);
+  prevSelected.current = baseState;
+  // useOptimistic allows immediate updates during transitions/actions
+  const [optimisticState, setOptimisticState] = useOptimistic<
+    T | TrackedActionState
+  >(null!);
+
+  // Ref keeps the latest selector for subscription callbacks without
+  // re-subscribing on every render. Selector changes themselves are not
+  // treated as a reactive input; this hook expects a stable selector and
+  // represents one subscription/projection for one action.
+  const selectorRef = useRef(selector);
+  selectorRef.current = selector;
+
+  // Subscribe to action state changes from event controller
+  useEffect(() => {
+    if (!ctx) return;
+
+    // Sync current state for the (possibly new) actionId so that switching
+    // actions on an idle page doesn't leave stale data from the old action.
+    const currentState = ctx.eventController.getActionState(actionId);
+    const currentSelected = selectorRef.current
+      ? selectorRef.current(currentState)
+      : currentState;
+    if (!shallowEqual(currentSelected, prevSelected.current)) {
+      prevSelected.current = currentSelected;
+      setBaseState(currentSelected);
+    }
+
+    // Subscribe to action-specific updates
+    const unsubscribe = ctx.eventController.subscribeToAction(
+      actionId,
+      (state) => {
+        const selectedState = selectorRef.current
+          ? selectorRef.current(state)
+          : state;
+
+        if (!shallowEqual(selectedState, prevSelected.current)) {
+          prevSelected.current = selectedState;
+          setBaseState(selectedState);
+          startTransition(() => {
+            setOptimisticState(selectedState);
+          });
+        }
+      },
+    );
+
+    return () => {
+      unsubscribe();
+    };
+  }, [actionId]);
+
+  return (optimisticState ?? baseState) as T | TrackedActionState;
+}
+
+export type { TrackedActionState };

package/src/browser/react/use-client-cache.ts

@@ -0,0 +1,58 @@
+"use client";
+
+import { useContext, useCallback } from "react";
+import { NavigationStoreContext } from "./context.js";
+
+/**
+ * Return type for useClientCache hook
+ */
+export interface ClientCacheControls {
+  /**
+   * Clear the client-side navigation cache.
+   * Call this after data changes that happen outside of server actions
+   * (e.g., REST API calls, WebSocket updates, etc.)
+   *
+   * This will also broadcast to other tabs to clear their caches.
+   */
+  clear: () => void;
+}
+
+/**
+ * Hook to access client-side cache controls
+ *
+ * Use this when you need to manually invalidate the navigation cache
+ * after data changes that happen outside of server actions.
+ *
+ * Server actions automatically clear the cache, so you only need this for:
+ * - REST API mutations
+ * - WebSocket-driven updates
+ * - Other non-RSC data changes
+ *
+ * @example
+ * ```tsx
+ * function DataEditor() {
+ *   const { clear } = useClientCache();
+ *
+ *   async function handleSave() {
+ *     await fetch('/api/data', { method: 'POST', body: JSON.stringify(data) });
+ *     // Clear cache so back/forward navigation shows fresh data
+ *     clear();
+ *   }
+ *
+ *   return <button onClick={handleSave}>Save</button>;
+ * }
+ * ```
+ */
+export function useClientCache(): ClientCacheControls {
+  const ctx = useContext(NavigationStoreContext);
+
+  if (!ctx) {
+    throw new Error("useClientCache must be used within NavigationProvider");
+  }
+
+  const clear = useCallback(() => {
+    ctx.store.clearHistoryCache();
+  }, [ctx]);
+
+  return { clear };
+}