wakujs/waku

Features

• Minimal Frameworks - A minimal React framework that builds applications with server components, client components, and server actions.
• File-Based Routing - Defines routes, layouts, and API endpoints by placing files in a directory, supporting dynamic segments, catch-all patterns, and route groups.
• Dynamic Page Renderings - Generates HTML for pages and layouts at request time to serve personalized or frequently changing content.
• Platform-Specific Adapters - Wraps server entries, request processing, and build steps with platform-specific adapters for deployment to various environments.
• Fixed Path Pages - Defines pages with fixed paths that render a single component at a specific URL.
• Client Component Hydrations - Hydrates components marked with a client directive in the browser to enable state, effects, and event handlers.
• Server Actions - Marks async functions with a 'use server' directive to execute server-side logic directly from client components.
• Server-Side Data Fetching - Fetches data on the server within async components, keeping sensitive logic off the client.
• API Routing - Creates server-side endpoints that handle HTTP requests and return JSON responses for client-side consumption.
• Island-Like Slice Compositions - Assembles pages from independently rendered reusable slice components that load statically or dynamically.
• Parameterized Route Definitions - Defines routes with dynamic segments, catch-all patterns, and nested segments that receive parsed parameters as props.
• Server Action Form Wrappers - Executes async functions marked with a directive server-side directly from client components and forms with automatic FormData handling.
• Parameterized Route Definitions - Defines pages with multiple variable path segments, each captured as a separate prop.
• Per-Page Rendering Modes - Prerenders each route at build time or renders it on each request, controlled by a render mode flag.
• Hybrid Rendering Strategies - Mixes static prerendering and dynamic per-request rendering within a single application with independently loading slice components.
• Server Components - Renders React components exclusively on the server for secure data fetching and reduced client bundles.
• Client Hydration Integrations - Renders React components exclusively on the server for data fetching, while client components hydrate in the browser for interactivity.
• Server-Client Composition Patterns - Weaves server and client components together by importing client components into server components and passing server-rendered content as props.
• Server Component Prop Passing - Passes server components as props to client components, enabling patterns like global context providers.
• Dynamic Segment Extraction - Captures named wildcards within URL paths to pass as variables to handlers.
• File-Based Layout Wrappings - Wraps routes and their descendants with a shared layout component defined by placing a layout file in the pages directory.
• Server-Side Endpoints - Defines server-side endpoints that handle HTTP requests and return JSON or other responses without a client-side component.
• Server Functions - Defines and invokes server-side functions directly from client components to perform mutations without manually setting up API endpoints.
• Typed Route Navigators - Provides typed router methods for navigating to dynamic routes with compile-time validation.
• Automatic Page Metadata Extraction - Sets title, meta, and link tags directly in components, which are automatically hoisted to the document head.
• Document Metadata Components - Adds title, meta, and link tags to the document head by placing them directly in any layout or page component.
• Documentation Metadata Configurations - Places title, meta, and link tags anywhere in a component tree, automatically hoisting them to the document head.
• Static Page Rendering - Generates static HTML at build time for pages and layouts to eliminate per-request processing.
• Static Site Generation - Generates static HTML at build time for pages and layouts, reducing runtime computation.
• Static Exports - Converts dynamic application routes into a set of static files for simple hosting.
• Static Build Deployments - Generates a fully static build that can be published to any static host without a server runtime.
• Static Site Deployment - Builds a fully static output that can be served without a Node.js runtime.
• Server-Side Render Interceptions - Registers functions that run before and after each render or API handler for context setup or logging.
• Catch-All Route Definitions - Matches indefinite URL segments and passes them as an ordered array to the page component.
• Component Lazy Loadings - Loads components independently from their parent page with a fallback while loading.
• Slice Lazy Loadings - Loads dynamic slice components independently from the rest of a static page with a fallback.
• Dynamic Slice Parameterizations - Extracts dynamic path segments and passes them as properties to a single component handling many IDs.
• Server Error Replays - Catches errors from server components and replays them in the browser for client-side error boundaries to handle.
• Request Interceptors - Registers middleware that runs before and after every render or API call, useful for context stores or security nonces.
• Composable Interceptors - Runs custom logic before and after each render or API handler via composable interceptors for context setup and logging.
• Request Middleware - Provides composable interceptors that wrap every render and API handler with custom logic.
• Dual-Context Components - Uses components that satisfy both server and client rules, allowing them to be imported into either context without creating a boundary.
• Render Wrapping Functions - Wraps each render and API handler with custom logic that runs before and after the request, such as setting up async local storage.
• Static or Dynamic Endpoint Registrations - Registers HTTP handlers at custom paths with support for static generation or dynamic execution.
• Page Metadata Overrides - Adds title, meta, and link tags to any layout or page component, which are automatically hoisted to the document head.
• Header-Based Context Maps - Reads request headers and passes request-scoped data to server components and server functions.
• URL Parameter - Extracts dynamic segments from a URL path and passes them as properties to a component handling many concrete identifiers.
• Dynamic Segment Parameterized Components - Builds components that extract dynamic URL segments and pass them as properties to handle multiple concrete identifiers.
• Navigation Links - Navigates between internal routes with automatic prefetching using a dedicated Link component.
• Client-Side Page Navigations - Moves between internal routes using a link component or programmatic navigation methods like push, replace, and back.
• Prefetching Navigations - Navigates between pages using client-side navigation, caching static payloads and preloading likely next routes.
• Independently Renderable Slices - Defines reusable components that render in their own mode (static or dynamic) and are composed into pages or layouts.
• Static or Dynamic Loading Slices - Creates independently renderable components that compose into pages, each loading in static or dynamic mode.
• File-Based Endpoint Definitions - Creates HTTP endpoints by exporting named functions for each method in a file within the API directory, returning standard Response objects.
• Programmatic Route Registrations - Registers pages, layouts, roots, slices, and API endpoints in code using a declarative API, replacing file-system routing.
• Slice-Based Page Assembly - Assembles pages by composing reusable slice components that load either statically or on demand.
• Document Head Management - Hoists title, meta, and link tags from any component into the document head automatically.
• Nested Layouts - Wraps routes and their descendants with a shared component by placing a layout file in the pages directory.
• Server Action Hooks - Integrates server actions with useTransition, useActionState, and useOptimistic for pending states and optimistic updates.
• HTTP Endpoint Mapping - Registers HTTP handlers at arbitrary paths with support for static prerendering or dynamic method dispatch.
• File-Based Method Endpoints - Creates HTTP endpoints by exporting named functions for each method in a file under the api directory.
• File-Based Method Handlers - Exports functions named after HTTP methods in a special directory to handle requests with standard Request and Response objects.
• Global Middleware Registration - Registers middleware functions that run on every request for cross-cutting concerns like logging.
• Programmatic Navigation - Inspects the current route and performs push, replace, reload, back, and forward navigation via a router hook.
• Hook-Based Route Inspections - Reads the current path and query string from a hook to drive component behavior.
• Request Metadata - Reads incoming request metadata and passes it to server components and server functions.
• Link Prefetchers - Prefetches internal link destinations ahead of navigation to improve page transition speed.
• Programmatic Route Registrations - Registers pages, layouts, and API routes through a JavaScript API, specifying render mode and path.
• Programmatic Router Definitions - Registers pages, layouts, and API endpoints in code using a declarative API, decoupling routing from the file system.
• Route Grouping - Groups related routes under a shared layout without affecting the URL structure.
• Infographic Server-Side Renderers - Renders a route from a static HTML shell instead of performing full server-side rendering for that page.
• Shared Layouts - Wraps a route and its descendants with a reusable layout component that can be statically or dynamically rendered.
• Per-Route SSR Disablings - Skips document SSR for a specific page, serving a fallback HTML shell while keeping the RSC payload available.
• Type-Safe Routing - Provides a typed interface for path parameters, query strings, and hash values on each page component.

Istoric stele