{"id": "47cb3dfffc9e-0", "text": "Defining Routes\nWe recommend reading the Routing Fundamentals page before continuing.\nThis page will guide you through how to define and organize routes in your Next.js application.\nCreating Routes\nNext.js uses a file-system based router where folders are used to define routes.\nEach folder represents a route segment that maps to a URL segment. To create a nested route, you can nest folders inside each other.\nA special page.js file is used to make route segments publicly accessible.\nIn this example, the /dashboard/analytics URL path is not publicly accessible because it does not have a corresponding page.js file. This folder could be used to store components, stylesheets, images, or other colocated files.\nGood to know: .js, .jsx, or .tsx file extensions can be used for special files.\nCreating UI", "source": "https://nextjs.org/docs/app/building-your-application/routing/defining-routes"}
{"id": "47cb3dfffc9e-1", "text": "Creating UI\nSpecial file conventions are used to create UI for each route segment. The most common are pages to show UI unique to a route, and layouts to show UI that is shared across multiple routes.\nFor example, to create your first page, add a page.js file inside the app directory and export a React component:\napp/page.tsx export default function Page() {\n  return <h1>Hello, Next.js!</h1>\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/defining-routes"}
{"id": "53efeaec8ff7-0", "text": "Pages and Layouts\nWe recommend reading the Routing Fundamentals and Defining Routes pages before continuing.\nThe App Router inside Next.js 13 introduced new file conventions to easily create pages, shared layouts, and templates. This page will guide you through how to use these special files in your Next.js application.\nPages\nA page is UI that is unique to a route. You can define pages by exporting a component from a page.js file. Use nested folders to define a route and a page.js file to make the route publicly accessible.\nCreate your first page by adding a page.js file inside the app directory:\napp/page.tsx // `app/page.tsx` is the UI for the `/` URL\nexport default function Page() {\n  return <h1>Hello, Home page!</h1>\n}\napp/dashboard/page.tsx // `app/dashboard/page.tsx` is the UI for the `/dashboard` URL\nexport default function Page() {", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-1", "text": "export default function Page() {\n  return <h1>Hello, Dashboard Page!</h1>\n}\nGood to know:\nA page is always the leaf of the route subtree.\n.js, .jsx, or .tsx file extensions can be used for Pages.\nA page.js file is required to make a route segment publicly accessible.\nPages are Server Components by default but can be set to a Client Component.\nPages can fetch data. View the Data Fetching section for more information.\nLayouts\nA layout is UI that is shared between multiple pages. On navigation, layouts preserve state, remain interactive, and do not re-render. Layouts can also be nested.\nYou can define a layout by default exporting a React component from a layout.js file. The component should accept a children prop that will be populated with a child layout (if it exists) or a child page during rendering.\napp/dashboard/layout.tsx export default function DashboardLayout({", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-2", "text": "app/dashboard/layout.tsx export default function DashboardLayout({\n  children, // will be a page or nested layout\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <section>\n      {/* Include shared UI here e.g. a header or sidebar */}\n      <nav></nav>\n \n      {children}\n    </section>\n  )\n}\nGood to know:\nThe top-most layout is called the Root Layout. This required layout is shared across all pages in an application. Root layouts must contain html and body tags.\nAny route segment can optionally define its own Layout. These layouts will be shared across all pages in that segment.\nLayouts in a route are nested by default. Each parent layout wraps child layouts below it using the React children prop.\nYou can use Route Groups to opt specific route segments in and out of shared layouts.", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-3", "text": "You can use Route Groups to opt specific route segments in and out of shared layouts.\nLayouts are Server Components by default but can be set to a Client Component.\nLayouts can fetch data. View the Data Fetching section for more information.\nPassing data between a parent layout and its children is not possible. However, you can fetch the same data in a route more than once, and React will automatically dedupe the requests without affecting performance.\nLayouts do not have access to the current route segment(s). To access route segments, you can use useSelectedLayoutSegment or useSelectedLayoutSegments in a Client Component.\n.js, .jsx, or .tsx file extensions can be used for Layouts.\nA layout.js and page.js file can be defined in the same folder. The layout will wrap the page.\nRoot Layout (Required)", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-4", "text": "Root Layout (Required)\nThe root layout is defined at the top level of the app directory and applies to all routes. This layout enables you to modify the initial HTML returned from the server.\napp/layout.tsx export default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n    </html>\n  )\n}\nGood to know:\nThe app directory must include a root layout.\nThe root layout must define <html> and <body> tags since Next.js does not automatically create them.\nYou can use the built-in SEO support to manage <head> HTML elements, for example, the <title> element.\nYou can use route groups to create multiple root layouts. See an example here.\nThe root layout is a Server Component by default and can not be set to a Client Component.", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-5", "text": "The root layout is a Server Component by default and can not be set to a Client Component.\nMigrating from the pages directory: The root layout replaces the _app.js and _document.js files. View the migration guide.\nNesting Layouts\nLayouts defined inside a folder (e.g. app/dashboard/layout.js) apply to specific route segments (e.g. acme.com/dashboard) and render when those segments are active. By default, layouts in the file hierarchy are nested, which means they wrap child layouts via their children prop.\napp/dashboard/layout.tsx export default function DashboardLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return <section>{children}</section>\n}\nGood to know:\nOnly the root layout can contain <html> and <body> tags.", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-6", "text": "Only the root layout can contain <html> and <body> tags.\nIf you were to combine the two layouts above, the root layout (app/layout.js) would wrap the dashboard layout (app/dashboard/layout.js), which would wrap route segments inside app/dashboard/*.\nThe two layouts would be nested as such:\nYou can use Route Groups to opt specific route segments in and out of shared layouts.\nTemplates\nTemplates are similar to layouts in that they wrap each child layout or page. Unlike layouts that persist across routes and maintain state, templates create a new instance for each of their children on navigation. This means that when a user navigates between routes that share a template, a new instance of the component is mounted, DOM elements are recreated, state is not preserved, and effects are re-synchronized.\nThere may be cases where you need those specific behaviors, and templates would be a more suitable option than layouts. For example:", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-7", "text": "Enter/exit animations using CSS or animation libraries.\nFeatures that rely on useEffect (e.g logging page views) and useState (e.g a per-page feedback form).\nTo change the default framework behavior. For example, Suspense Boundaries inside layouts only show the fallback the first time the Layout is loaded and not when switching pages. For templates, the fallback is shown on each navigation.\nRecommendation: We recommend using Layouts unless you have a specific reason to use Template.\nA template can be defined by exporting a default React component from a template.js file. The component should accept a children prop which will be nested segments.\napp/template.tsx export default function Template({ children }: { children: React.ReactNode }) {\n  return <div>{children}</div>\n}\nThe rendered output of a route segment with a layout and a template will be as such:\nOutput <Layout>\n  {/* Note that the template is given a unique key. */}", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-8", "text": "Output <Layout>\n  {/* Note that the template is given a unique key. */}\n  <Template key={routeParam}>{children}</Template>\n</Layout>\nModifying <head>\nIn the app directory, you can modify the <head> HTML elements such as title and meta using the built-in SEO support.\nMetadata can be defined by exporting a metadata object or generateMetadata function in a layout.js or page.js file.\napp/page.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: 'Next.js',\n}\n \nexport default function Page() {\n  return '...'\n}\nGood to know: You should not manually add <head> tags such as <title> and <meta> to root layouts. Instead, you should use the Metadata API which automatically handles advanced requirements such as streaming and de-duplicating <head> elements.", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "53efeaec8ff7-9", "text": "Learn more about available metadata options in the API reference.", "source": "https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts"}
{"id": "7259cc670011-0", "text": "Linking and NavigatingThe Next.js router uses server-centric routing with client-side navigation. It supports instant loading states and concurrent rendering. This means navigation maintains client-side state, avoids expensive re-renders, is interruptible, and doesn't cause race conditions.\nThere are two ways to navigate between routes:\n<Link> Component\nuseRouter Hook\nThis page will go through how to use <Link>, useRouter(), and dive deeper into how navigation works.\n<Link> Component\n<Link> is a React component that extends the HTML <a> element to provide prefetching and client-side navigation between routes. It is the primary way to navigate between routes in Next.js.\nTo use <Link>, import it from next/link, and pass a href prop to the component:\napp/page.tsx import Link from 'next/link'\n \nexport default function Page() {\n  return <Link href=\"/dashboard\">Dashboard</Link>\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-1", "text": "return <Link href=\"/dashboard\">Dashboard</Link>\n}\nThere are optional props you can pass to <Link>. See the API reference for more information.\nExamples\nLinking to Dynamic Segments\nWhen linking to dynamic segments, you can use template literals and interpolation to generate a list of links. For example, to generate a list of blog posts:\napp/blog/PostList.js import Link from 'next/link'\n \nexport default function PostList({ posts }) {\n  return (\n    <ul>\n      {posts.map((post) => (\n        <li key={post.id}>\n          <Link href={`/blog/${post.slug}`}>{post.title}</Link>\n        </li>\n      ))}\n    </ul>\n  )\n}\nChecking Active Links", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-2", "text": "))}\n    </ul>\n  )\n}\nChecking Active Links\nYou can use usePathname() to determine if a link is active. For example, to add a class to the active link, you can check if the current pathname matches the href of the link:\napp/ui/Navigation.js 'use client'\n \nimport { usePathname } from 'next/navigation'\nimport Link from 'next/link'\n \nexport function Navigation({ navLinks }) {\n  const pathname = usePathname()\n \n  return (\n    <>\n      {navLinks.map((link) => {\n        const isActive = pathname.startsWith(link.href)\n \n        return (\n          <Link\n            className={isActive ? 'text-blue' : 'text-black'}\n            href={link.href}\n            key={link.name}\n          >\n            {link.name}\n          </Link>\n        )", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-3", "text": ">\n            {link.name}\n          </Link>\n        )\n      })}\n    </>\n  )\n}\nScrolling to an id\nThe default behavior of <Link> is to scroll to the top of the route segment that has changed. When there is an id defined in href, it will scroll to the specific id, similarly to a normal <a> tag.\nuseRouter() Hook\nThe useRouter hook allows you to programmatically change routes inside Client Components.\nTo use useRouter, import it from next/navigation, and call the hook inside your Client Component:\napp/page.js 'use client'\n \nimport { useRouter } from 'next/navigation'\n \nexport default function Page() {\n  const router = useRouter()\n \n  return (\n    <button type=\"button\" onClick={() => router.push('/dashboard')}>\n      Dashboard\n    </button>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-4", "text": "Dashboard\n    </button>\n  )\n}\nThe useRouter provides methods such as push(), refresh(), and more. See the API reference for more information.\nRecommendation: Use the <Link> component to navigate between routes unless you have a specific requirement for using useRouter.\nHow Navigation Works\nA route transition is initiated using <Link> or calling router.push().\nThe router updates the URL in the browser's address bar.\nThe router avoids unnecessary work by re-using segments that haven't changed (e.g. shared layouts) from the client-side cache. This is also referred to as partial rendering.\nIf the conditions of soft navigation are met, the router fetches the new segment from the cache rather than the server. If not, the router performs a hard navigation and fetches the Server Component payload from the server.\nIf created, loading UI is shown from the server while the payload is being fetched.", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-5", "text": "If created, loading UI is shown from the server while the payload is being fetched.\nThe router uses the cached or fresh payload to render the new segments on the client.\nClient-side Caching of Rendered Server Components\nGood to know: This client-side cache is different from the server-side Next.js HTTP cache.\nThe new router has an in-memory client-side cache that stores the rendered result of Server Components (payload). The cache is split by route segments which allows invalidation at any level and ensures consistency across concurrent renders.\nAs users navigate around the app, the router will store the payload of previously fetched segments and prefetched segments in the cache.\nThis means, for certain cases, the router can re-use the cache instead of making a new request to the server. This improves performance by avoiding re-fetching data and re-rendering components unnecessarily.\nInvalidating the Cache", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-6", "text": "Invalidating the Cache\nServer Actions can be used to revalidate data on-demand by path (revalidatePath) or by cache tag (revalidateTag).\nPrefetching\nPrefetching is a way to preload a route in the background before it's visited. The rendered result of prefetched routes is added to the router's client-side cache. This makes navigating to a prefetched route near-instant.\nBy default, routes are prefetched as they become visible in the viewport when using the <Link> component. This can happen when the page first loads or through scrolling. Routes can also be programmatically prefetched using the prefetch method of the useRouter() hook.\nStatic and Dynamic Routes:\nIf the route is static, all the Server Component payloads for the route segments will be prefetched.", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-7", "text": "If the route is dynamic, the payload from the first shared layout down until the first loading.js file is prefetched. This reduces the cost of prefetching the whole route dynamically and allows instant loading states for dynamic routes.\nGood to know:\nPrefetching is only enabled in production.\nPrefetching can be disabled by passing prefetch={false} to <Link>.\nSoft Navigation\nOn navigation, the cache for changed segments is reused (if it exists), and no new requests are made to the server for data.\nConditions for Soft Navigation\nOn navigation, Next.js will use soft navigation if the route you are navigating to has been prefetched, and either doesn't include dynamic segments or has the same dynamic parameters as the current route.\nFor example, consider the following route that includes a dynamic [team] segment: /dashboard/[team]/*. The cached segments below /dashboard/[team]/* will only be invalidated when the [team] parameter changes.", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "7259cc670011-8", "text": "Navigating from /dashboard/team-red/* to /dashboard/team-red/* will be a soft navigation.\nNavigating from /dashboard/team-red/* to /dashboard/team-blue/* will be a hard navigation.\nHard Navigation\nOn navigation, the cache is invalidated and the server refetches data and re-renders the changed segments.\nBack/Forward Navigation\nBack and forward navigation (popstate event) has a soft navigation behavior. This means, the client-side cache is re-used and navigation is near-instant.\nFocus and Scroll Management\nBy default, Next.js will set focus and scroll into view the segment that's changed on navigation.", "source": "https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating"}
{"id": "34bf98e60183-0", "text": "Route GroupsIn the app directory, nested folders are normally mapped to URL paths. However, you can mark a folder as a Route Group to prevent the folder from being included in the route's URL path.\nThis allows you to organize your route segments and project files into logical groups without affecting the URL path structure.\nRoute groups are useful for:\nOrganizing routes into groups e.g. by site section, intent, or team.\nEnabling nested layouts in the same route segment level:\nCreating multiple nested layouts in the same segment, including multiple root layouts\nAdding a layout to a subset of routes in a common segment\nConvention\nA route group can be created by wrapping a folder's name in parenthesis: (folderName)\nExamples\nOrganize routes without affecting the URL path\nTo organize routes without affecting the URL, create a group to keep related routes together. The folders in parenthesis will be omitted from the URL (e.g. (marketing) or (shop)).", "source": "https://nextjs.org/docs/app/building-your-application/routing/route-groups"}
{"id": "34bf98e60183-1", "text": "Even though routes inside (marketing) and (shop) share the same URL hierarchy, you can create a different layout for each group by adding a layout.js file inside their folders.\nOpting specific segments into a layout\nTo opt specific routes into a layout, create a new route group (e.g. (shop)) and move the routes that share the same layout into the group (e.g. account and cart). The routes outside of the group will not share the layout (e.g. checkout).\nCreating multiple root layouts\nTo create multiple root layouts, remove the top-level layout.js file, and add a layout.js file inside each route groups. This is useful for partitioning an application into sections that have a completely different UI or experience. The <html> and <body> tags need to be added to each root layout.\nIn the example above, both (marketing) and (shop) have their own root layout.\nGood to know:", "source": "https://nextjs.org/docs/app/building-your-application/routing/route-groups"}
{"id": "34bf98e60183-2", "text": "Good to know:\nThe naming of route groups has no special significance other than for organization. They do not affect the URL path.\nRoutes that include a route group should not resolve to the same URL path as other routes. For example, since route groups don't affect URL structure, (marketing)/about/page.js and (shop)/about/page.js would both resolve to /about and cause an error.\nIf you use multiple root layouts without a top-level layout.js file, your home page.js file should be defined in one of the route groups, For example: app/(marketing)/page.js.\nNavigating across multiple root layouts will cause a full page load (as opposed to a client-side navigation). For example, navigating from /cart that uses app/(shop)/layout.js to /blog that uses app/(marketing)/layout.js will cause a full page load. This only applies to multiple root layouts.", "source": "https://nextjs.org/docs/app/building-your-application/routing/route-groups"}
{"id": "45cae5895537-0", "text": "Dynamic RoutesWhen you don't know the exact segment names ahead of time and want to create routes from dynamic data, you can use Dynamic Segments that are filled in at request time or prerendered at build time.\nConvention\nA Dynamic Segment can be created by wrapping a folder's name in square brackets: [folderName]. For example, [id] or [slug].\nDynamic Segments are passed as the params prop to layout, page, route, and generateMetadata functions.\nExample\nFor example, a blog could include the following route app/blog/[slug]/page.js where [slug] is the Dynamic Segment for blog posts.\napp/blog/[slug]/page.tsx export default function Page({ params }: { params: { slug: string } }) {\n  return <div>My Post: {params.slug}</div>\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes"}
{"id": "45cae5895537-1", "text": "return <div>My Post: {params.slug}</div>\n}\nRouteExample URLparamsapp/blog/[slug]/page.js/blog/a{ slug: 'a' }app/blog/[slug]/page.js/blog/b{ slug: 'b' }app/blog/[slug]/page.js/blog/c{ slug: 'c' }\nSee the generateStaticParams() page to learn how to generate the params for the segment.\nGood to know: Dynamic Segments are equivalent to Dynamic Routes in the pages directory.\nGenerating Static Params\nThe generateStaticParams function can be used in combination with dynamic route segments to statically generate routes at build time instead of on-demand at request time.\napp/blog/[slug]/page.tsx export async function generateStaticParams() {\n  const posts = await fetch('https://.../posts').then((res) => res.json())\n \n  return posts.map((post) => ({\n    slug: post.slug,", "source": "https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes"}
{"id": "45cae5895537-2", "text": "return posts.map((post) => ({\n    slug: post.slug,\n  }))\n}\nThe primary benefit of the generateStaticParams function is its smart retrieval of data. If content is fetched within the generateStaticParams function using a fetch request, the requests are automatically deduplicated. This means a fetch request with the same arguments across multiple generateStaticParams, Layouts, and Pages will only be made once, which decreases build times.\nUse the migration guide if you are migrating from the pages directory.\nSee generateStaticParams server function documentation for more information and advanced use cases.\nCatch-all Segments\nDynamic Segments can be extended to catch-all subsequent segments by adding an ellipsis inside the brackets [...folderName].\nFor example, app/shop/[...slug]/page.js will match /shop/clothes, but also /shop/clothes/tops, /shop/clothes/tops/t-shirts, and so on.", "source": "https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes"}
{"id": "45cae5895537-3", "text": "RouteExample URLparamsapp/shop/[...slug]/page.js/shop/a{ slug: ['a'] }app/shop/[...slug]/page.js/shop/a/b{ slug: ['a', 'b'] }app/shop/[...slug]/page.js/shop/a/b/c{ slug: ['a', 'b', 'c'] }\nOptional Catch-all Segments\nCatch-all Segments can be made optional by including the parameter in double square brackets: [[...folderName]].\nFor example, app/shop/[[...slug]]/page.js will also match /shop, in addition to /shop/clothes, /shop/clothes/tops, /shop/clothes/tops/t-shirts.\nThe difference between catch-all and optional catch-all segments is that with optional, the route without the parameter is also matched (/shop in the example above).", "source": "https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes"}
{"id": "45cae5895537-4", "text": "RouteExample URLparamsapp/shop/[[...slug]]/page.js/shop{}app/shop/[[...slug]]/page.js/shop/a{ slug: ['a'] }app/shop/[[...slug]]/page.js/shop/a/b{ slug: ['a', 'b'] }app/shop/[[...slug]]/page.js/shop/a/b/c{ slug: ['a', 'b', 'c'] }\nTypeScript\nWhen using TypeScript, you can add types for params depending on your configured route segment.\napp/blog/[slug]/page.tsx export default function Page({ params }: { params: { slug: string } }) {\n  return <h1>My Page</h1>\n}\nRouteparams Type Definitionapp/blog/[slug]/page.js{ slug: string }app/shop/[...slug]/page.js{ slug: string[] }app/[categoryId]/[itemId]/page.js{ categoryId: string, itemId: string }", "source": "https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes"}
{"id": "45cae5895537-5", "text": "Good to know: This may be done automatically by the TypeScript plugin in the future.", "source": "https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes"}
{"id": "4cb9ccf64b03-0", "text": "Loading UI and StreamingThe special file loading.js helps you create meaningful Loading UI with React Suspense. With this convention, you can show an instant loading state from the server while the content of a route segment loads. The new content is automatically swapped in once rendering is complete.\nInstant Loading States\nAn instant loading state is fallback UI that is shown immediately upon navigation. You can pre-render loading indicators such as skeletons and spinners, or a small but meaningful part of future screens such as a cover photo, title, etc. This helps users understand the app is responding and provides a better user experience.\nCreate a loading state by adding a loading.js file inside a folder.\napp/dashboard/loading.tsx export default function Loading() {\n  // You can add any UI inside Loading, including a Skeleton.\n  return <LoadingSkeleton />\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming"}
{"id": "4cb9ccf64b03-1", "text": "return <LoadingSkeleton />\n}\nIn the same folder, loading.js will be nested inside layout.js. It will automatically wrap the page.js file and any children below in a <Suspense> boundary.\nGood to know:\nNavigation is immediate, even with server-centric routing.\nNavigation is interruptible, meaning changing routes does not need to wait for the content of the route to fully load before navigating to another route.\nShared layouts remain interactive while new route segments load.\nRecommendation: Use the loading.js convention for route segments (layouts and pages) as Next.js optimizes this functionality.\nStreaming with Suspense\nIn addition to loading.js, you can also manually create Suspense Boundaries for your own UI components. The App Router supports streaming with Suspense for both Node.js and Edge runtimes.\nWhat is Streaming?", "source": "https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming"}
{"id": "4cb9ccf64b03-2", "text": "What is Streaming?\nTo learn how Streaming works in React and Next.js, it's helpful to understand Server-Side Rendering (SSR) and its limitations.\nWith SSR, there's a series of steps that need to be completed before a user can see and interact with a page:\nFirst, all data for a given page is fetched on the server.\nThe server then renders the HTML for the page.\nThe HTML, CSS, and JavaScript for the page are sent to the client.\nA non-interactive user interface is shown using the generated HTML, and CSS.\nFinally, React hydrates the user interface to make it interactive.\nThese steps are sequential and blocking, meaning the server can only render the HTML for a page once all the data has been fetched. And, on the client, React can only hydrate the UI once the code for all components in the page has been downloaded.", "source": "https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming"}
{"id": "4cb9ccf64b03-3", "text": "SSR with React and Next.js helps improve the perceived loading performance by showing a non-interactive page to the user as soon as possible.\nHowever, it can still be slow as all data fetching on server needs to be completed before the page can be shown to the user.\nStreaming allows you to break down the page's HTML into smaller chunks and progressively send those chunks from the server to the client.\nThis enables parts of the page to be displayed sooner, without waiting for all the data to load before any UI can be rendered.\nStreaming works well with React's component model because each component can be considered a chunk. Components that have higher priority (e.g. product information) or that don't rely on data can be sent first (e.g. layout), and React can start hydration earlier. Components that have lower priority (e.g. reviews, related products) can be sent in the same server request after their data has been fetched.", "source": "https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming"}
{"id": "4cb9ccf64b03-4", "text": "Streaming is particularly beneficial when you want to prevent long data requests from blocking the page from rendering as it can reduce the Time To First Byte (TTFB) and First Contentful Paint (FCP). It also helps improve Time to Interactive (TTI), especially on slower devices.\nExample\n<Suspense> works by wrapping a component that performs an asynchronous action (e.g. fetch data), showing fallback UI (e.g. skeleton, spinner) while it's happening, and then swapping in your component once the action completes.\napp/dashboard/page.tsx import { Suspense } from 'react'\nimport { PostFeed, Weather } from './Components'\n \nexport default function Posts() {\n  return (\n    <section>\n      <Suspense fallback={<p>Loading feed...</p>}>\n        <PostFeed />\n      </Suspense>\n      <Suspense fallback={<p>Loading weather...</p>}>\n        <Weather />", "source": "https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming"}
{"id": "4cb9ccf64b03-5", "text": "<Suspense fallback={<p>Loading weather...</p>}>\n        <Weather />\n      </Suspense>\n    </section>\n  )\n}\nBy using Suspense, you get the benefits of:\nStreaming Server Rendering - Progressively rendering HTML from the server to the client.\nSelective Hydration - React prioritizes what components to make interactive first based on user interaction.\nFor more Suspense examples and use cases, please see the React Documentation.\nSEO\nNext.js will wait for data fetching inside generateMetadata to complete before streaming UI to the client. This guarantees the first part of a streamed response includes <head> tags.\nSince streaming is server-rendered, it does not impact SEO. You can use the Mobile Friendly Test tool from Google to see how your page appears to Google's web crawlers and view the serialized HTML (source).", "source": "https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming"}
{"id": "5829a47ac78e-0", "text": "Error HandlingThe error.js file convention allows you to gracefully handle unexpected runtime errors in nested routes.\nAutomatically wrap a route segment and its nested children in a React Error Boundary.\nCreate error UI tailored to specific segments using the file-system hierarchy to adjust granularity.\nIsolate errors to affected segments while keeping the rest of the application functional.\nAdd functionality to attempt to recover from an error without a full page reload.\nCreate error UI by adding an error.js file inside a route segment and exporting a React component:\napp/dashboard/error.tsx 'use client' // Error components must be Client Components\n \nimport { useEffect } from 'react'\n \nexport default function Error({\n  error,\n  reset,\n}: {\n  error: Error\n  reset: () => void\n}) {\n  useEffect(() => {\n    // Log the error to an error reporting service\n    console.error(error)\n  }, [error])", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "5829a47ac78e-1", "text": "console.error(error)\n  }, [error])\n \n  return (\n    <div>\n      <h2>Something went wrong!</h2>\n      <button\n        onClick={\n          // Attempt to recover by trying to re-render the segment\n          () => reset()\n        }\n      >\n        Try again\n      </button>\n    </div>\n  )\n}\nHow error.js Works\nerror.js automatically creates an React Error Boundary that wraps a nested child segment or page.js component.\nThe React component exported from the error.js file is used as the fallback component.\nIf an error is thrown within the error boundary, the error is contained, and the fallback component is rendered.\nWhen the fallback error component is active, layouts above the error boundary maintain their state and remain interactive, and the error component can display functionality to recover from the error.\nRecovering From Errors", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "5829a47ac78e-2", "text": "Recovering From Errors\nThe cause of an error can sometimes be temporary. In these cases, simply trying again might resolve the issue.\nAn error component can use the reset() function to prompt the user to attempt to recover from the error. When executed, the function will try to re-render the Error boundary's contents. If successful, the fallback error component is replaced with the result of the re-render.\napp/dashboard/error.tsx 'use client'\n \nexport default function Error({\n  error,\n  reset,\n}: {\n  error: Error\n  reset: () => void\n}) {\n  return (\n    <div>\n      <h2>Something went wrong!</h2>\n      <button onClick={() => reset()}>Try again</button>\n    </div>\n  )\n}\nNested Routes\nReact components created through special files are rendered in a specific nested hierarchy.", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "5829a47ac78e-3", "text": "}\nNested Routes\nReact components created through special files are rendered in a specific nested hierarchy.\nFor example, a nested route with two segments that both include layout.js and error.js files are rendered in the following simplified component hierarchy:\nThe nested component hierarchy has implications for the behavior of error.js files across a nested route:\nErrors bubble up to the nearest parent error boundary. This means an error.js file will handle errors for all its nested child segments. More or less granular error UI can be achieved by placing error.js files at different levels in the nested folders of a route.\nAn error.js boundary will not handle errors thrown in a layout.js component in the same segment because the error boundary is nested inside that layouts component.\nHandling Errors in Layouts", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "5829a47ac78e-4", "text": "Handling Errors in Layouts\nerror.js boundaries do not catch errors thrown in layout.js or template.js components of the same segment. This intentional hierarchy keeps important UI that is shared between sibling routes (such as navigation) visible and functional when an error occurs.\nTo handle errors within a specific layout or template, place an error.js file in the layouts parent segment.\nTo handle errors within the root layout or template, use a variation of error.js called global-error.js.\nHandling Errors in Root Layouts\nThe root app/error.js boundary does not catch errors thrown in the root app/layout.js or app/template.js component.\nTo specifically handle errors in these root components, use a variation of error.js called app/global-error.js located in the root app directory.", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "5829a47ac78e-5", "text": "Unlike the root error.js, the global-error.js error boundary wraps the entire application, and its fallback component replaces the root layout when active. Because of this, it is important to note that global-error.js must define its own <html> and <body> tags.\nglobal-error.js is the least granular error UI and can be considered \"catch-all\" error handling for the whole application. It is unlikely to be triggered often as root components are typically less dynamic, and other error.js boundaries will catch most errors.\nEven if a global-error.js is defined, it is still recommended to define a root error.js whose fallback component will be rendered within the root layout, which includes globally shared UI and branding.\napp/global-error.tsx 'use client'\n \nexport default function GlobalError({\n  error,\n  reset,\n}: {\n  error: Error\n  reset: () => void\n}) {\n  return (\n    <html>", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "5829a47ac78e-6", "text": "reset: () => void\n}) {\n  return (\n    <html>\n      <body>\n        <h2>Something went wrong!</h2>\n        <button onClick={() => reset()}>Try again</button>\n      </body>\n    </html>\n  )\n}\nHandling Server Errors\nIf an error is thrown inside a Server Component, Next.js will forward an Error object (stripped of sensitive error information in production) to the nearest error.js file as the error prop.\nSecuring Sensitive Error Information\nDuring production, the Error object forwarded to the client only includes a generic message and digest property.\nThis is a security precaution to avoid leaking potentially sensitive details included in the error to the client.\nThe message property contains a generic message about the error and the digest property contains an automatically generated hash of the error that can be used to match the corresponding error in server-side logs.", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "5829a47ac78e-7", "text": "During development, the Error object forwarded to the client will be serialized and include the message of the original error for easier debugging.", "source": "https://nextjs.org/docs/app/building-your-application/routing/error-handling"}
{"id": "04c394e53e49-0", "text": "Parallel RoutesParallel Routing allows you to simultaneously or conditionally render one or more pages in the same layout. For highly dynamic sections of an app, such as dashboards and feeds on social sites, Parallel Routing can be used to implement complex routing patterns.\nFor example, you can simultaneously render the team and analytics pages.\nParallel Routing allows you to define independent error and loading states for each route as they're being streamed in independently.\nParallel Routing also allows you to conditionally render a slot based on certain conditions, such as authentication state. This enables fully separated code on the same URL.\nConvention\nParallel routes are created using named slots. Slots are defined with the @folder convention, and are passed to the same-level layout as props.\nSlots are not route segments and do not affect the URL structure. The file path /@team/members would be accessible at /members.\nFor example, the following file structure defines two explicit slots: @analytics and @team.", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "04c394e53e49-1", "text": "For example, the following file structure defines two explicit slots: @analytics and @team.\nThe folder structure above means that the component in app/layout.js now accepts the @analytics and @team slots props, and can render them in parallel alongside the children prop:\napp/layout.tsx export default function Layout(props: {\n  children: React.ReactNode\n  analytics: React.ReactNode\n  team: React.ReactNode\n}) {\n  return (\n    <>\n      {props.children}\n      {props.team}\n      {props.analytics}\n    </>\n  )\n}\nGood to know: The children prop is an implicit slot that does not need to be mapped to a folder. This means app/page.js is equivalent to app/@children/page.js.\nUnmatched Routes\nBy default, the content rendered within a slot will match the current URL.", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "04c394e53e49-2", "text": "Unmatched Routes\nBy default, the content rendered within a slot will match the current URL.\nIn the case of an unmatched slot, the content that Next.js renders differs based on the routing technique and folder structure.\ndefault.js\nYou can define a default.js file to render as a fallback when Next.js cannot recover a slot's active state based on the current URL.\nConsider the following folder structure. The @team slot has a settings directory, but @analytics does not.\nIf you were to navigate from the root / to /settings, the content that gets rendered is different based on the type of navigation and the availability of the default.js file.\nWith @analytics/default.jsWithout @analytics/default.jsSoft Navigation@team/settings/page.js and @analytics/page.js@team/settings/page.js and @analytics/page.jsHard Navigation@team/settings/page.js and @analytics/default.js404\nSoft Navigation", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "04c394e53e49-3", "text": "Soft Navigation\nOn a soft navigation - Next.js will render the slot's previously active state, even if it doesn't match the current URL.\nHard Navigation\nOn a hard navigation - a navigation that requires a full page reload - Next.js will first try to render the unmatched slot's default.js file. If that's not available, a 404 gets rendered.\nThe 404 for unmatched routes helps ensure that you don't accidentally render a route that shouldn't be parallel rendered.\nuseSelectedLayoutSegment(s)\nBoth useSelectedLayoutSegment and useSelectedLayoutSegments accept a parallelRoutesKey, which allows you read the active route segment within that slot.\napp/layout.tsx 'use client'\n \nimport { useSelectedLayoutSegment } from 'next/navigation'\n \nexport default async function Layout(props: {\n  //...\n  authModal: React.ReactNode\n}) {\n  const loginSegments = useSelectedLayoutSegment('authModal')", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "04c394e53e49-4", "text": "}) {\n  const loginSegments = useSelectedLayoutSegment('authModal')\n  // ...\n}\nWhen a user navigates to @authModal/login, or /login in the URL bar, loginSegments will be equal to the string \"login\".\nExamples\nModals\nParallel Routing can be used to render modals.\nThe @authModal slot renders a <Modal> component that can be shown by navigating to a matching route, for example /login.\napp/layout.tsx export default async function Layout(props: {\n  // ...\n  authModal: React.ReactNode\n}) {\n  return (\n    <>\n      {/* ... */}\n      {props.authModal}\n    </>\n  )\n}\napp/@authModal/login/page.tsx import { Modal } from 'components/modal'\n \nexport default function Login() {\n  return (\n    <Modal>\n      <h1>Login</h1>", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "04c394e53e49-5", "text": "return (\n    <Modal>\n      <h1>Login</h1>\n      {/* ... */}\n    </Modal>\n  )\n}\nTo ensure that the contents of the modal don't get rendered when it's not active, you can create a default.js file that returns null.\napp/@authModal/default.tsx export default function Default() {\n  return null\n}\nDismissing a modal\nIf a modal was initiated through client navigation, e.g. by using <Link href=\"/login\">, you can dismiss the modal by calling router.back() or by using a Link component.\napp/@authModal/login/page.tsx 'use client'\nimport { useRouter } from 'next/navigation'\nimport { Modal } from 'components/modal'\n \nexport default async function Login() {\n  const router = useRouter()\n  return (\n    <Modal>", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "04c394e53e49-6", "text": "const router = useRouter()\n  return (\n    <Modal>\n      <span onClick={() => router.back()}>Close modal</span>\n      <h1>Login</h1>\n      ...\n    </Modal>\n  )\n}\nMore information on modals is covered in the Intercepting Routes section.\nIf you want to navigate elsewhere and dismiss a modal, you can also use a catch-all route.\napp/@authModal/[...catchAll]/page.tsx export default function CatchAll() {\n  return null\n}\nCatch-all routes take precedence over default.js.\nConditional Routes\nParallel Routes can be used to implement conditional routing. For example, you can render a @dashboard or @login route depending on the authentication state.\napp/layout.tsx import { getUser } from '@/lib/auth'\n \nexport default function Layout({\n  dashboard,\n  login,\n}: {\n  dashboard: React.ReactNode", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "04c394e53e49-7", "text": "dashboard,\n  login,\n}: {\n  dashboard: React.ReactNode\n  login: React.ReactNode\n}) {\n  const isLoggedIn = getUser()\n  return isLoggedIn ? dashboard : login\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/parallel-routes"}
{"id": "01dc1cccd23e-0", "text": "Intercepting RoutesIntercepting routes allows you to load a route within the current layout while keeping the context for the current page. This routing paradigm can be useful when you want to \"intercept\" a certain route to show a different route.\nFor example, when clicking on a photo from within a feed, a modal overlaying the feed should show up with the photo. In this case, Next.js intercepts the /feed route and \"masks\" this URL to show /photo/123 instead.\nHowever, when navigating to the photo directly by for example when clicking a shareable URL or by refreshing the page, the entire photo page should render instead of the modal. No route interception should occur.\nConvention\nIntercepting routes can be defined with the (..) convention, which is similar to relative path convention ../ but for segments.\nYou can use:\n(.) to match segments on the same level\n(..) to match segments one level above", "source": "https://nextjs.org/docs/app/building-your-application/routing/intercepting-routes"}
{"id": "01dc1cccd23e-1", "text": "(.) to match segments on the same level\n(..) to match segments one level above\n(..)(..) to match segments two levels above\n(...) to match segments from the root app directory\nFor example, you can intercept the photo segment from within the feed segment by creating a (..)photo directory.\nNote that the (..) convention is based on route segments, not the file-system.\nExamples\nModals\nIntercepting Routes can be used together with Parallel Routes to create modals.\nUsing this pattern to create modals overcomes some common challenges when working with modals, by allowing you to:\nMake the modal content shareable through a URL\nPreserve context when the page is refreshed, instead of closing the modal\nClose the modal on backwards navigation rather than going to the previous route\nReopen the modal on forwards navigation", "source": "https://nextjs.org/docs/app/building-your-application/routing/intercepting-routes"}
{"id": "01dc1cccd23e-2", "text": "Reopen the modal on forwards navigation\nIn the above example, the path to the photo segment can use the (..) matcher since @modal is a slot and not a segment. This means that the photo route is only one segment level higher, despite being two file-system levels higher.\nOther examples could include opening a login modal in a top navbar while also having a dedicated /login page, or opening a shopping cart in a side modal.\nView an example of modals with Intercepted and Parallel Routes.", "source": "https://nextjs.org/docs/app/building-your-application/routing/intercepting-routes"}
{"id": "e771e7a1daa6-0", "text": "Route HandlersRoute Handlers allow you to create custom request handlers for a given route using the Web Request and Response APIs.\nGood to know: Route Handlers are only available inside the app directory. They are the equivalent of API Routes inside the pages directory meaning you do not need to use API Routes and Route Handlers together.\nConvention\nRoute Handlers are defined in a route.js|ts file inside the app directory:\napp/api/route.ts export async function GET(request: Request) {}\nRoute Handlers can be nested inside the app directory, similar to page.js and layout.js. But there cannot be a route.js file at the same route segment level as page.js.\nSupported HTTP Methods\nThe following HTTP methods are supported: GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS. If an unsupported method is called, Next.js will return a 405 Method Not Allowed response.\nExtended NextRequest and NextResponse APIs", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-1", "text": "Extended NextRequest and NextResponse APIs\nIn addition to supporting native Request and Response. Next.js extends them with\nNextRequest and NextResponse to provide convenient helpers for advanced use cases.\nBehavior\nStatic Route Handlers\nRoute Handlers are statically evaluated by default when using the GET method with the Response object.\napp/items/route.ts import { NextResponse } from 'next/server'\n \nexport async function GET() {\n  const res = await fetch('https://data.mongodb-api.com/...', {\n    headers: {\n      'Content-Type': 'application/json',\n      'API-Key': process.env.DATA_API_KEY,\n    },\n  })\n  const data = await res.json()\n \n  return NextResponse.json({ data })\n}\nTypeScript Warning: Although Response.json() is valid, native TypeScript types currently shows an error, you can use NextResponse.json() for typed responses instead.\nDynamic Route Handlers", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-2", "text": "Dynamic Route Handlers\nRoute handlers are evaluated dynamically when:\nUsing the Request object with the GET method.\nUsing any of the other HTTP methods.\nUsing Dynamic Functions like cookies and headers.\nThe Segment Config Options manually specifies dynamic mode.\nFor example:\napp/products/api/route.ts import { NextResponse } from 'next/server'\n \nexport async function GET(request: Request) {\n  const { searchParams } = new URL(request.url)\n  const id = searchParams.get('id')\n  const res = await fetch(`https://data.mongodb-api.com/product/${id}`, {\n    headers: {\n      'Content-Type': 'application/json',\n      'API-Key': process.env.DATA_API_KEY,\n    },\n  })\n  const product = await res.json()\n \n  return NextResponse.json({ product })\n}\nSimilarly, the POST method will cause the Route Handler to be evaluated dynamically.", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-3", "text": "}\nSimilarly, the POST method will cause the Route Handler to be evaluated dynamically.\napp/items/route.ts import { NextResponse } from 'next/server'\n \nexport async function POST() {\n  const res = await fetch('https://data.mongodb-api.com/...', {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n      'API-Key': process.env.DATA_API_KEY,\n    },\n    body: JSON.stringify({ time: new Date().toISOString() }),\n  })\n \n  const data = await res.json()\n \n  return NextResponse.json(data)\n}\nGood to know: Like API Routes, Route Handlers can be used for cases like handling form submissions. A new abstraction for handling forms and mutations that integrates deeply with React is being worked on.\nRoute Resolution\nYou can consider a route the lowest level routing primitive.", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-4", "text": "Route Resolution\nYou can consider a route the lowest level routing primitive.\nThey do not participate in layouts or client-side navigations like page.\nThere cannot be a route.js file at the same route as page.js.\nPageRouteResultapp/page.jsapp/route.js Conflictapp/page.jsapp/api/route.js Validapp/[user]/page.jsapp/api/route.js Valid\nEach route.js or page.js file takes over all HTTP verbs for that route.\napp/page.js export default function Page() {\n  return <h1>Hello, Next.js!</h1>\n}\n \n// \u274c Conflict\n// `app/route.js`\nexport async function POST(request) {}\nExamples\nThe following examples show how to combine Route Handlers with other Next.js APIs and features.\nRevalidating Static Data\nYou can revalidate static data fetches using the next.revalidate option:", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-5", "text": "You can revalidate static data fetches using the next.revalidate option:\napp/items/route.ts import { NextResponse } from 'next/server'\n \nexport async function GET() {\n  const res = await fetch('https://data.mongodb-api.com/...', {\n    next: { revalidate: 60 }, // Revalidate every 60 seconds\n  })\n  const data = await res.json()\n \n  return NextResponse.json(data)\n}\nAlternatively, you can use the revalidate segment config option:\n export const revalidate = 60\nDynamic Functions\nRoute Handlers can be used with dynamic functions from Next.js, like cookies and headers.\nCookies\nYou can read cookies with cookies from next/headers. This server function can be called directly in a Route Handler, or nested inside of another function.", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-6", "text": "This cookies instance is read-only. To set cookies, you need to return a new Response using the Set-Cookie header.\napp/api/route.ts import { cookies } from 'next/headers'\n \nexport async function GET(request: Request) {\n  const cookieStore = cookies()\n  const token = cookieStore.get('token')\n \n  return new Response('Hello, Next.js!', {\n    status: 200,\n    headers: { 'Set-Cookie': `token=${token.value}` },\n  })\n}\nAlternatively, you can use abstractions on top of the underlying Web APIs to read cookies (NextRequest):\napp/api/route.ts import { type NextRequest } from 'next/server'\n \nexport async function GET(request: NextRequest) {\n  const token = request.cookies.get('token')\n}\nHeaders", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-7", "text": "const token = request.cookies.get('token')\n}\nHeaders\nYou can read headers with headers from next/headers. This server function can be called directly in a Route Handler, or nested inside of another function.\nThis headers instance is read-only. To set headers, you need to return a new Response with new headers.\napp/api/route.ts import { headers } from 'next/headers'\n \nexport async function GET(request: Request) {\n  const headersList = headers()\n  const referer = headersList.get('referer')\n \n  return new Response('Hello, Next.js!', {\n    status: 200,\n    headers: { referer: referer },\n  })\n}\nAlternatively, you can use abstractions on top of the underlying Web APIs to read headers (NextRequest):\napp/api/route.ts import { type NextRequest } from 'next/server'", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-8", "text": "app/api/route.ts import { type NextRequest } from 'next/server'\n \nexport async function GET(request: NextRequest) {\n  const requestHeaders = new Headers(request.headers)\n}\nRedirects\napp/api/route.ts import { redirect } from 'next/navigation'\n \nexport async function GET(request: Request) {\n  redirect('https://nextjs.org/')\n}\nDynamic Route Segments\nWe recommend reading the Defining Routes page before continuing.\nRoute Handlers can use Dynamic Segments to create request handlers from dynamic data.\napp/items/[slug]/route.ts export async function GET(\n  request: Request,\n  { params }: { params: { slug: string } }\n) {\n  const slug = params.slug // 'a', 'b', or 'c'\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-9", "text": "const slug = params.slug // 'a', 'b', or 'c'\n}\nRouteExample URLparamsapp/items/[slug]/route.js/items/a{ slug: 'a' }app/items/[slug]/route.js/items/b{ slug: 'b' }app/items/[slug]/route.js/items/c{ slug: 'c' }\nStreaming\nStreaming is commonly used in combination with Large Language Models (LLMs), such an OpenAI, for AI-generated content. Learn more about the AI SDK.\napp/api/completion/route.ts import { Configuration, OpenAIApi } from 'openai-edge'\nimport { OpenAIStream, StreamingTextResponse } from 'ai'\n \nconst config = new Configuration({\n  apiKey: process.env.OPENAI_API_KEY,\n})\nconst openai = new OpenAIApi(config)\n \nexport const runtime = 'edge'", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-10", "text": "export const runtime = 'edge'\n \nexport async function POST(req: Request) {\n  const { prompt } = await req.json()\n  const response = await openai.createCompletion({\n    model: 'text-davinci-003',\n    stream: true,\n    temperature: 0.6,\n    prompt: 'What is Next.js?',\n  })\n \n  const stream = OpenAIStream(response)\n  return new StreamingTextResponse(stream)\n}\nThese abstractions use the Web APIs to create a stream. You can also use the underlying Web APIs directly.\napp/api/route.ts // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream#convert_async_iterator_to_stream\nfunction iteratorToStream(iterator: any) {\n  return new ReadableStream({\n    async pull(controller) {\n      const { value, done } = await iterator.next()", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-11", "text": "const { value, done } = await iterator.next()\n \n      if (done) {\n        controller.close()\n      } else {\n        controller.enqueue(value)\n      }\n    },\n  })\n}\n \nfunction sleep(time: number) {\n  return new Promise((resolve) => {\n    setTimeout(resolve, time)\n  })\n}\n \nconst encoder = new TextEncoder()\n \nasync function* makeIterator() {\n  yield encoder.encode('<p>One</p>')\n  await sleep(200)\n  yield encoder.encode('<p>Two</p>')\n  await sleep(200)\n  yield encoder.encode('<p>Three</p>')\n}\n \nexport async function GET() {\n  const iterator = makeIterator()\n  const stream = iteratorToStream(iterator)\n \n  return new Response(stream)\n}\nRequest Body", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-12", "text": "return new Response(stream)\n}\nRequest Body\nYou can read the Request body using the standard Web API methods:\napp/items/route.ts import { NextResponse } from 'next/server'\n \nexport async function POST(request: Request) {\n  const res = await request.json()\n  return NextResponse.json({ res })\n}\nRequest Body FormData\nYou can read the FormData using the the request.formData() function:\napp/items/route.ts import { NextResponse } from 'next/server'\n \nexport async function POST(request: Request) {\n  const formData = await request.formData()\n  const name = formData.get('name')\n  const email = formData.get('email')\n  return NextResponse.json({ name, email })\n}\nSince formData data are all strings, you may want to use zod-form-data to validate the request and retrieve data in the format you prefer (e.g. number).", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-13", "text": "CORS\nYou can set CORS headers on a Response using the standard Web API methods:\napp/api/route.ts export async function GET(request: Request) {\n  return new Response('Hello, Next.js!', {\n    status: 200,\n    headers: {\n      'Access-Control-Allow-Origin': '*',\n      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',\n      'Access-Control-Allow-Headers': 'Content-Type, Authorization',\n    },\n  })\n}\nEdge and Node.js Runtimes\nRoute Handlers have an isomorphic Web API to support both Edge and Node.js runtimes seamlessly, including support for streaming. Since Route Handlers use the same route segment configuration as Pages and Layouts, they support long-awaited features like general-purpose statically regenerated Route Handlers.\nYou can use the runtime segment config option to specify the runtime:\n export const runtime = 'edge' // 'nodejs' is the default", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-14", "text": "export const runtime = 'edge' // 'nodejs' is the default\nNon-UI Responses\nYou can use Route Handlers to return non-UI content. Note that sitemap.xml, robots.txt, app icons, and open graph images all have built-in support.\napp/rss.xml/route.ts export async function GET() {\n  return new Response(`<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<rss version=\"2.0\">\n \n<channel>\n  <title>Next.js Documentation</title>\n  <link>https://nextjs.org/docs</link>\n  <description>The React Framework for the Web</description>\n</channel>\n \n</rss>`)\n}\nSegment Config Options\nRoute Handlers use the same route segment configuration as pages and layouts.\napp/items/route.ts export const dynamic = 'auto'\nexport const dynamicParams = true", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "e771e7a1daa6-15", "text": "app/items/route.ts export const dynamic = 'auto'\nexport const dynamicParams = true\nexport const revalidate = false\nexport const fetchCache = 'auto'\nexport const runtime = 'nodejs'\nexport const preferredRegion = 'auto'\nSee the API reference for more details.", "source": "https://nextjs.org/docs/app/building-your-application/routing/router-handlers"}
{"id": "baccacb331d2-0", "text": "Middleware\nMiddleware allows you to run code before a request is completed. Then, based on the incoming request, you can modify the response by rewriting, redirecting, modifying the request or response headers, or responding directly.\nMiddleware runs before cached content and routes are matched. See Matching Paths for more details.\nConvention\nUse the file middleware.ts (or .js) in the root of your project to define Middleware. For example, at the same level as pages or app, or inside src if applicable.\nExample\nmiddleware.ts import { NextResponse } from 'next/server'\nimport type { NextRequest } from 'next/server'\n \n// This function can be marked `async` if using `await` inside\nexport function middleware(request: NextRequest) {\n  return NextResponse.redirect(new URL('/home', request.url))\n}\n \n// See \"Matching Paths\" below to learn more\nexport const config = {", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-1", "text": "// See \"Matching Paths\" below to learn more\nexport const config = {\n  matcher: '/about/:path*',\n}\nMatching Paths\nMiddleware will be invoked for every route in your project. The following is the execution order:\nheaders from next.config.js\nredirects from next.config.js\nMiddleware (rewrites, redirects, etc.)\nbeforeFiles (rewrites) from next.config.js\nFilesystem routes (public/, _next/static/, pages/, app/, etc.)\nafterFiles (rewrites) from next.config.js\nDynamic Routes (/blog/[slug])\nfallback (rewrites) from next.config.js\nThere are two ways to define which paths Middleware will run on:\nCustom matcher config\nConditional statements\nMatcher\nmatcher allows you to filter Middleware to run on specific paths.\nmiddleware.js export const config = {\n  matcher: '/about/:path*',\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-2", "text": "middleware.js export const config = {\n  matcher: '/about/:path*',\n}\nYou can match a single path or multiple paths with an array syntax:\nmiddleware.js export const config = {\n  matcher: ['/about/:path*', '/dashboard/:path*'],\n}\nThe matcher config allows full regex so matching like negative lookaheads or character matching is supported. An example of a negative lookahead to match all except specific paths can be seen here:\nmiddleware.js export const config = {\n  matcher: [\n    /*\n     * Match all request paths except for the ones starting with:\n     * - api (API routes)\n     * - _next/static (static files)\n     * - _next/image (image optimization files)\n     * - favicon.ico (favicon file)\n     */\n    '/((?!api|_next/static|_next/image|favicon.ico).*)',\n  ],\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-3", "text": "],\n}\nGood to know: The matcher values need to be constants so they can be statically analyzed at build-time. Dynamic values such as variables will be ignored.\nConfigured matchers:\nMUST start with /\nCan include named parameters: /about/:path matches /about/a and /about/b but not /about/a/c\nCan have modifiers on named parameters (starting with :): /about/:path* matches /about/a/b/c because * is zero or more. ? is zero or one and + one or more\nCan use regular expression enclosed in parenthesis: /about/(.*) is the same as /about/:path*\nRead more details on path-to-regexp documentation.\nGood to know: For backward compatibility, Next.js always considers /public as /public/index. Therefore, a matcher of /public/:path will match.\nConditional Statements\nmiddleware.ts import { NextResponse } from 'next/server'", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-4", "text": "Conditional Statements\nmiddleware.ts import { NextResponse } from 'next/server'\nimport type { NextRequest } from 'next/server'\n \nexport function middleware(request: NextRequest) {\n  if (request.nextUrl.pathname.startsWith('/about')) {\n    return NextResponse.rewrite(new URL('/about-2', request.url))\n  }\n \n  if (request.nextUrl.pathname.startsWith('/dashboard')) {\n    return NextResponse.rewrite(new URL('/dashboard/user', request.url))\n  }\n}\nNextResponse\nThe NextResponse API allows you to:\nredirect the incoming request to a different URL\nrewrite the response by displaying a given URL\nSet request headers for API Routes, getServerSideProps, and rewrite destinations\nSet response cookies\nSet response headers\nTo produce a response from Middleware, you can:\nrewrite to a route (Page or Route Handler) that produces a response", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-5", "text": "rewrite to a route (Page or Route Handler) that produces a response\nreturn a NextResponse directly. See Producing a Response\nUsing Cookies\nCookies are regular headers. On a Request, they are stored in the Cookie header. On a Response they are in the Set-Cookie header. Next.js provides a convenient way to access and manipulate these cookies through the cookies extension on NextRequest and NextResponse.\nFor incoming requests, cookies comes with the following methods: get, getAll, set, and delete cookies. You can check for the existence of a cookie with has or remove all cookies with clear.\nFor outgoing responses, cookies have the following methods get, getAll, set, and delete.\nmiddleware.ts import { NextResponse } from 'next/server'\nimport type { NextRequest } from 'next/server'\n \nexport function middleware(request: NextRequest) {\n  // Assume a \"Cookie:nextjs=fast\" header to be present on the incoming request", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-6", "text": "// Getting cookies from the request using the `RequestCookies` API\n  let cookie = request.cookies.get('nextjs')\n  console.log(cookie) // => { name: 'nextjs', value: 'fast', Path: '/' }\n  const allCookies = request.cookies.getAll()\n  console.log(allCookies) // => [{ name: 'nextjs', value: 'fast' }]\n \n  request.cookies.has('nextjs') // => true\n  request.cookies.delete('nextjs')\n  request.cookies.has('nextjs') // => false\n \n  // Setting cookies on the response using the `ResponseCookies` API\n  const response = NextResponse.next()\n  response.cookies.set('vercel', 'fast')\n  response.cookies.set({\n    name: 'vercel',\n    value: 'fast',\n    path: '/',\n  })\n  cookie = response.cookies.get('vercel')", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-7", "text": "path: '/',\n  })\n  cookie = response.cookies.get('vercel')\n  console.log(cookie) // => { name: 'vercel', value: 'fast', Path: '/' }\n  // The outgoing response will have a `Set-Cookie:vercel=fast;path=/test` header.\n \n  return response\n}\nSetting Headers\nYou can set request and response headers using the NextResponse API (setting request headers is available since Next.js v13.0.0).\nmiddleware.ts import { NextResponse } from 'next/server'\nimport type { NextRequest } from 'next/server'\n \nexport function middleware(request: NextRequest) {\n  // Clone the request headers and set a new header `x-hello-from-middleware1`\n  const requestHeaders = new Headers(request.headers)\n  requestHeaders.set('x-hello-from-middleware1', 'hello')", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-8", "text": "requestHeaders.set('x-hello-from-middleware1', 'hello')\n \n  // You can also set request headers in NextResponse.rewrite\n  const response = NextResponse.next({\n    request: {\n      // New request headers\n      headers: requestHeaders,\n    },\n  })\n \n  // Set a new response header `x-hello-from-middleware2`\n  response.headers.set('x-hello-from-middleware2', 'hello')\n  return response\n}\nGood to know: Avoid setting large headers as it might cause 431 Request Header Fields Too Large error depending on your backend web server configuration.\nProducing a Response\nYou can respond from Middleware directly by returning a Response or NextResponse instance. (This is available since Next.js v13.1.0)\nmiddleware.ts import { NextRequest, NextResponse } from 'next/server'\nimport { isAuthenticated } from '@lib/auth'", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-9", "text": "import { isAuthenticated } from '@lib/auth'\n \n// Limit the middleware to paths starting with `/api/`\nexport const config = {\n  matcher: '/api/:function*',\n}\n \nexport function middleware(request: NextRequest) {\n  // Call our authentication function to check the request\n  if (!isAuthenticated(request)) {\n    // Respond with JSON indicating an error message\n    return new NextResponse(\n      JSON.stringify({ success: false, message: 'authentication failed' }),\n      { status: 401, headers: { 'content-type': 'application/json' } }\n    )\n  }\n}\nAdvanced Middleware Flags\nIn v13.1 of Next.js two additional flags were introduced for middleware, skipMiddlewareUrlNormalize and skipTrailingSlashRedirect to handle advanced use cases.", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-10", "text": "skipTrailingSlashRedirect allows disabling Next.js default redirects for adding or removing trailing slashes allowing custom handling inside middleware which can allow maintaining the trailing slash for some paths but not others allowing easier incremental migrations.\nnext.config.js module.exports = {\n  skipTrailingSlashRedirect: true,\n}\nmiddleware.js const legacyPrefixes = ['/docs', '/blog']\n \nexport default async function middleware(req) {\n  const { pathname } = req.nextUrl\n \n  if (legacyPrefixes.some((prefix) => pathname.startsWith(prefix))) {\n    return NextResponse.next()\n  }\n \n  // apply trailing slash handling\n  if (\n    !pathname.endsWith('/') &&\n    !pathname.match(/((?!\\.well-known(?:\\/.*)?)(?:[^/]+\\/)*[^/]+\\.\\w+)/)\n  ) {\n    req.nextUrl.pathname += '/'\n    return NextResponse.redirect(req.nextUrl)\n  }", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-11", "text": "return NextResponse.redirect(req.nextUrl)\n  }\n}\nskipMiddlewareUrlNormalize allows disabling the URL normalizing Next.js does to make handling direct visits and client-transitions the same. There are some advanced cases where you need full control using the original URL which this unlocks.\nnext.config.js module.exports = {\n  skipMiddlewareUrlNormalize: true,\n}\nmiddleware.js export default async function middleware(req) {\n  const { pathname } = req.nextUrl\n \n  // GET /_next/data/build-id/hello.json\n \n  console.log(pathname)\n  // with the flag this now /_next/data/build-id/hello.json\n  // without the flag this would be normalized to /hello\n}\nVersion History", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "baccacb331d2-12", "text": "// without the flag this would be normalized to /hello\n}\nVersion History\nVersionChangesv13.1.0Advanced Middleware flags addedv13.0.0Middleware can modify request headers, response headers, and send responsesv12.2.0Middleware is stable, please see the upgrade guidev12.0.9Enforce absolute URLs in Edge Runtime (PR)v12.0.0Middleware (Beta) added", "source": "https://nextjs.org/docs/app/building-your-application/routing/middleware"}
{"id": "51e8ce814bef-0", "text": "Project Organization and File ColocationApart from routing folder and file conventions, Next.js is unopinionated about how you organize and colocate your project files.\nThis page shares default behavior and features you can use to organize your project.\nSafe colocation by default\nProject organization features\nProject organization strategies\nSafe colocation by default\nIn the app directory, nested folder hierarchy defines route structure.\nEach folder represents a route segment that is mapped to a corresponding segment in a URL path.\nHowever, even though route structure is defined through folders, a route is not publicly accessible until a page.js or route.js file is added to a route segment.\nAnd, even when a route is made publicly accessible, only the content returned by page.js or route.js is sent to the client.\nThis means that project files can be safely colocated inside route segments in the app directory without accidentally being routable.\nGood to know:", "source": "https://nextjs.org/docs/app/building-your-application/routing/colocation"}
{"id": "51e8ce814bef-1", "text": "Good to know:\nThis is different from the pages directory, where any file in pages is considered a route.\nWhile you can colocate your project files in app you don't have to. If you prefer, you can keep them outside the app directory.\nProject organization features\nNext.js provides several features to help you organize your project.\nPrivate Folders\nPrivate folders can be created by prefixing a folder with an underscore: _folderName\nThis indicates the folder is a private implementation detail and should not be considered by the routing system, thereby opting the folder and all its subfolders out of routing.\nSince files in the app directory can be safely colocated by default, private folders are not required for colocation. However, they can be useful for:\nSeparating UI logic from routing logic.\nConsistently organizing internal files across a project and the Next.js ecosystem.\nSorting and grouping files in code editors.", "source": "https://nextjs.org/docs/app/building-your-application/routing/colocation"}
{"id": "51e8ce814bef-2", "text": "Sorting and grouping files in code editors.\nAvoiding potential naming conflicts with future Next.js file conventions.\nGood to know\nWhile not a framework convention, you might also consider marking files outside private folders as \"private\" using the same underscore pattern.\nYou can create URL segments that start with an underscore by prefixing the folder name with %5F (the URL-encoded form of an underscore): %5FfolderName.\nIf you don't use private folders, it would be helpful to know Next.js special file conventions to prevent unexpected naming conflicts.\nRoute Groups\nRoute groups can be created by wrapping a folder in parenthesis: (folderName)\nThis indicates the folder is for organizational purposes and should not be included in the route's URL path.\nRoute groups are useful for:\nOrganizing routes into groups e.g. by site section, intent, or team.\nEnabling nested layouts in the same route segment level:", "source": "https://nextjs.org/docs/app/building-your-application/routing/colocation"}
{"id": "51e8ce814bef-3", "text": "Enabling nested layouts in the same route segment level:\nCreating multiple nested layouts in the same segment, including multiple root layouts\nAdding a layout to a subset of routes in a common segment\nsrc Directory\nNext.js supports storing application code (including app) inside an optional src directory. This separates application code from project configuration files which mostly live in the root of a project.\nModule Path Aliases\nNext.js supports Module Path Aliases which make it easier to read and maintain imports across deeply nested project files.\napp/dashboard/settings/analytics/page.js // before\nimport { Button } from '../../../components/button'\n \n// after\nimport { Button } from '@/components/button'\nProject organization strategies\nThere is no \"right\" or \"wrong\" way when it comes to organizing your own files and folders in a Next.js project.", "source": "https://nextjs.org/docs/app/building-your-application/routing/colocation"}
{"id": "51e8ce814bef-4", "text": "The following section lists a very high-level overview of common strategies. The simplest takeaway is to choose a strategy that works for you and your team and be consistent across the project.\nGood to know: In our examples below, we're using components and lib folders as generalized placeholders, their naming has no special framework significance and your projects might use other folders like ui, utils, hooks, styles, etc.\nStore project files outside of app\nThis strategy stores all application code in shared folders in the root of your project and keeps the app directory purely for routing purposes.\nStore project files in top-level folders inside of app\nThis strategy stores all application code in shared folders in the root of the app directory.\nSplit project files by feature or route\nThis strategy stores globally shared application code in the root app directory and splits more specific application code into the route segments that use them.", "source": "https://nextjs.org/docs/app/building-your-application/routing/colocation"}
{"id": "7159bd219a09-0", "text": "InternationalizationNext.js enables you to configure the routing and rendering of content to support multiple languages. Making your site adaptive to different locales includes translated content (localization) and internationalized routes.\nTerminology\nLocale: An identifier for a set of language and formatting preferences. This usually includes the preferred language of the user and possibly their geographic region.\nen-US: English as spoken in the United States\nnl-NL: Dutch as spoken in the Netherlands\nnl: Dutch, no specific region\nRouting Overview\nIt\u2019s recommended to use the user\u2019s language preferences in the browser to select which locale to use. Changing your preferred language will modify the incoming Accept-Language header to your application.\nFor example, using the following libraries, you can look at an incoming Request to determine which locale to select, based on the Headers, locales you plan to support, and the default locale.\nmiddleware.js import { match } from '@formatjs/intl-localematcher'", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "7159bd219a09-1", "text": "middleware.js import { match } from '@formatjs/intl-localematcher'\nimport Negotiator from 'negotiator'\n \nlet headers = { 'accept-language': 'en-US,en;q=0.5' }\nlet languages = new Negotiator({ headers }).languages()\nlet locales = ['en-US', 'nl-NL', 'nl']\nlet defaultLocale = 'en-US'\n \nmatch(languages, locales, defaultLocale) // -> 'en-US'\nRouting can be internationalized by either the sub-path (/fr/products) or domain (my-site.fr/products). With this information, you can now redirect the user based on the locale inside Middleware.\nmiddleware.js import { NextResponse } from 'next/server'\n \nlet locales = ['en-US', 'nl-NL', 'nl']\n \n// Get the preferred locale, similar to above or using a library\nfunction getLocale(request) { ... }", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "7159bd219a09-2", "text": "function getLocale(request) { ... }\n \nexport function middleware(request) {\n  // Check if there is any supported locale in the pathname\n  const pathname = request.nextUrl.pathname\n  const pathnameIsMissingLocale = locales.every(\n    (locale) => !pathname.startsWith(`/${locale}/`) && pathname !== `/${locale}`\n  )\n \n  // Redirect if there is no locale\n  if (pathnameIsMissingLocale) {\n    const locale = getLocale(request)\n \n    // e.g. incoming request is /products\n    // The new URL is now /en-US/products\n    return NextResponse.redirect(\n      new URL(`/${locale}/${pathname}`, request.url)\n    )\n  }\n}\n \nexport const config = {\n  matcher: [\n    // Skip all internal paths (_next)\n    '/((?!_next).*)',", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "7159bd219a09-3", "text": "// Skip all internal paths (_next)\n    '/((?!_next).*)',\n    // Optional: only run on root (/) URL\n    // '/'\n  ],\n}\nFinally, ensure all special files inside app/ are nested under app/[lang]. This enables the Next.js router to dynamically handle different locales in the route, and forward the lang parameter to every layout and page. For example:\napp/[lang]/page.js // You now have access to the current locale\n// e.g. /en-US/products -> `lang` is \"en-US\"\nexport default async function Page({ params: { lang } }) {\n  return ...\n}\nThe root layout can also be nested in the new folder (e.g. app/[lang]/layout.js).\nLocalization", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "7159bd219a09-4", "text": "Localization\nChanging displayed content based on the user\u2019s preferred locale, or localization, is not something specific to Next.js. The patterns described below would work the same with any web application.\nLet\u2019s assume we want to support both English and Dutch content inside our application. We might maintain two different \u201cdictionaries\u201d, which are objects that give us a mapping from some key to a localized string. For example:\ndictionaries/en.json {\n  \"products\": {\n    \"cart\": \"Add to Cart\"\n  }\n}\ndictionaries/nl.json {\n  \"products\": {\n    \"cart\": \"Toevoegen aan Winkelwagen\"\n  }\n}\nWe can then create a getDictionary function to load the translations for the requested locale:\napp/[lang]/dictionaries.js import 'server-only'\n \nconst dictionaries = {", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "7159bd219a09-5", "text": "app/[lang]/dictionaries.js import 'server-only'\n \nconst dictionaries = {\n  en: () => import('./dictionaries/en.json').then((module) => module.default),\n  nl: () => import('./dictionaries/nl.json').then((module) => module.default),\n}\n \nexport const getDictionary = async (locale) => dictionaries[locale]()\nGiven the currently selected language, we can fetch the dictionary inside of a layout or page.\napp/[lang]/page.js import { getDictionary } from './dictionaries'\n \nexport default async function Page({ params: { lang } }) {\n  const dict = await getDictionary(lang) // en\n  return <button>{dict.products.cart}</button> // Add to Cart\n}", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "7159bd219a09-6", "text": "return <button>{dict.products.cart}</button> // Add to Cart\n}\nBecause all layouts and pages in the app/ directory default to Server Components, we do not need to worry about the size of the translation files affecting our client-side JavaScript bundle size. This code will only run on the server, and only the resulting HTML will be sent to the browser.\nStatic Generation\nTo generate static routes for a given set of locales, we can use generateStaticParams with any page or layout. This can be global, for example, in the root layout:\napp/[lang]/layout.js export async function generateStaticParams() {\n  return [{ lang: 'en-US' }, { lang: 'de' }]\n}\n \nexport default function Root({ children, params }) {\n  return (\n    <html lang={params.lang}>\n      <body>{children}</body>\n    </html>\n  )\n}\nExamples", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "7159bd219a09-7", "text": "</html>\n  )\n}\nExamples\nMinimal i18n routing and translations\nnext-intl", "source": "https://nextjs.org/docs/app/building-your-application/routing/internationalization"}
{"id": "092d651651e2-0", "text": "Static and Dynamic RenderingIn Next.js, a route can be statically or dynamically rendered.\nIn a static route, components are rendered on the server at build time. The result of the work is cached and reused on subsequent requests.\nIn a dynamic route, components are rendered on the server at request time.\nStatic Rendering (Default)\nBy default, Next.js statically renders routes to improve performance. This means all the rendering work is done ahead of time and can be served from a Content Delivery Network (CDN) geographically closer to the user.\nStatic Data Fetching (Default)\nBy default, Next.js will cache the result of fetch() requests that do not specifically opt out of caching behavior. This means that fetch requests that do not set a cache option will use the force-cache option.\nIf any fetch requests in the route use the revalidate option, the route will be re-rendered statically during revalidation.", "source": "https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering"}
{"id": "092d651651e2-1", "text": "To learn more about caching data fetching requests, see the Caching and Revalidating page.\nDynamic Rendering\nDuring static rendering, if a dynamic function or a dynamic fetch() request (no caching) is discovered, Next.js will switch to dynamically rendering the whole route at request time. Any cached data requests can still be re-used during dynamic rendering.\nThis table summarizes how dynamic functions and caching affect the rendering behavior of a route:\nData FetchingDynamic FunctionsRenderingStatic (Cached)NoStaticStatic (Cached)YesDynamicNot CachedNoDynamicNot CachedYesDynamic\nNote how dynamic functions always opt the route into dynamic rendering, regardless of whether the data fetching is cached or not. In other words, static rendering is dependent not only on the data fetching behavior, but also on the dynamic functions used in the route.", "source": "https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering"}
{"id": "092d651651e2-2", "text": "Good to know: In the future, Next.js will introduce hybrid server-side rendering where layouts and pages in a route can be independently statically or dynamically rendered, instead of the whole route.\nDynamic Functions\nDynamic functions rely on information that can only be known at request time such as a user's cookies, current requests headers, or the URL's search params. In Next.js, these dynamic functions are:\nUsing cookies() or headers() in a Server Component will opt the whole route into dynamic rendering at request time.\nUsing useSearchParams() in Client Components will skip static rendering and instead render all Client Components up to the nearest parent Suspense boundary on the client.\nWe recommend wrapping the Client Component that uses useSearchParams() in a <Suspense/> boundary. This will allow any Client Components above it to be statically rendered. Example.\nUsing the searchParams Pages prop will opt the page into dynamic rendering at request time.\nDynamic Data Fetching", "source": "https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering"}
{"id": "092d651651e2-3", "text": "Dynamic Data Fetching\nDynamic data fetches are fetch() requests that specifically opt out of caching behavior by setting the cache option to 'no-store' or revalidate to 0.\nThe caching options for all fetch requests in a layout or page can also be set using the segment config object.\nTo learn more about Dynamic Data Fetching, see the Data Fetching page.", "source": "https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering"}
{"id": "d0539c74aec9-0", "text": "Edge and Node.js Runtimes\nIn the context of Next.js, \"runtime\" refers to the set of libraries, APIs, and general functionality available to your code during execution.\nNext.js has two server runtimes where you can render parts of your application code:\nNode.js Runtime\nEdge Runtime\nEach runtime has its own set of APIs. Please refer to the Node.js Docs and Edge Docs for the full list of available APIs. Both runtimes can also support streaming depending on your deployment infrastructure.\nBy default, the app directory uses the Node.js runtime. However, you can opt into different runtimes (e.g. Edge) on a per-route basis.\nRuntime Differences\nThere are many considerations to make when choosing a runtime. This table shows the major differences at a glance. If you want a more in-depth analysis of the differences, check out the sections below.", "source": "https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes"}
{"id": "d0539c74aec9-1", "text": "NodeServerlessEdgeCold Boot/~250msInstantHTTP StreamingYesYesYesIOAllAllfetchScalability/HighHighestSecurityNormalHighHighLatencyNormalLowLowestnpm PackagesAllAllA smaller subset\nEdge Runtime\nIn Next.js, the lightweight Edge Runtime is a subset of available Node.js APIs.\nThe Edge Runtime is ideal if you need to deliver dynamic, personalized content at low latency with small, simple functions. The Edge Runtime's speed comes from its minimal use of resources, but that can be limiting in many scenarios.\nFor example, code executed in the Edge Runtime on Vercel cannot exceed between 1 MB and 4 MB, this limit includes imported packages, fonts and files, and will vary depending on your deployment infrastructure.\nNode.js Runtime\nUsing the Node.js runtime gives you access to all Node.js APIs, and all npm packages that rely on them. However, it's not as fast to start up as routes using the Edge runtime.", "source": "https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes"}
{"id": "d0539c74aec9-2", "text": "Deploying your Next.js application to a Node.js server will require managing, scaling, and configuring your infrastructure. Alternatively, you can consider deploying your Next.js application to a serverless platform like Vercel, which will handle this for you.\nServerless Node.js\nServerless is ideal if you need a scalable solution that can handle more complex computational loads than the Edge Runtime. With Serverless Functions on Vercel, for example, your overall code size is 50MB including imported packages, fonts, and files.\nThe downside compared to routes using the Edge is that it can take hundreds of milliseconds for Serverless Functions to boot up before they begin processing requests. Depending on the amount of traffic your site receives, this could be a frequent occurrence as the functions are not frequently \"warm\".\nExamples\nSegment Runtime Option", "source": "https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes"}
{"id": "d0539c74aec9-3", "text": "Examples\nSegment Runtime Option\nYou can specify a runtime for individual route segments in your Next.js application. To do so, declare a variable called runtime and export it. The variable must be a string, and must have a value of either 'nodejs' or 'edge' runtime.The following example demonstrates a page route segment that exports a runtime with a value of 'edge':app/page.tsx export const runtime = 'edge' // 'nodejs' (default) | 'edge'You can also define runtime on a layout level, which will make all routes under the layout run on the edge runtime:app/layout.tsx export const runtime = 'edge' // 'nodejs' (default) | 'edge'If the segment runtime is not set, the default nodejs runtime will be used. You do not need to use the runtime option if you do not plan to change from the Node.js runtime.", "source": "https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes"}
{"id": "175f38087dac-0", "text": "Data FetchingThe Next.js App Router allows you to fetch data directly in your React components by marking the function as async and using await for the Promise.\nData fetching is built on top of the fetch() Web API and React Server Components. When using fetch(), requests are automatically deduped by default.\nNext.js extends the fetch options object to allow each request to set its own caching and revalidating.\nasync and await in Server Components\nYou can use async and await to fetch data in Server Components.\napp/page.tsx async function getData() {\n  const res = await fetch('https://api.example.com/...')\n  // The return value is *not* serialized\n  // You can return Date, Map, Set, etc.\n \n  // Recommendation: handle errors\n  if (!res.ok) {\n    // This will activate the closest `error.js` Error Boundary\n    throw new Error('Failed to fetch data')", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-1", "text": "throw new Error('Failed to fetch data')\n  }\n \n  return res.json()\n}\n \nexport default async function Page() {\n  const data = await getData()\n \n  return <main></main>\n}\nGood to know:\nTo use an async Server Component with TypeScript, ensure you are using TypeScript 5.1.3 or higher and @types/react 18.2.8 or higher.\nServer Component Functions\nNext.js provides helpful server functions you may need when fetching data in Server Components:\ncookies()\nheaders()\nuse in Client Components\nuse is a new React function that accepts a promise conceptually similar to await. use handles the promise returned by a function in a way that is compatible with components, hooks, and Suspense. Learn more about use in the React RFC.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-2", "text": "Wrapping fetch in use is currently not recommended in Client Components and may trigger multiple re-renders. For now, if you need to fetch data in a Client Component, we recommend using a third-party library such as SWR or React Query.\nGood to know: We'll be adding more examples once fetch and use work in Client Components.\nStatic Data Fetching\nBy default, fetch will automatically fetch and cache data indefinitely.\n fetch('https://...') // cache: 'force-cache' is the default\nRevalidating Data\nTo revalidate cached data at a timed interval, you can use the next.revalidate option in fetch() to set the cache lifetime of a resource (in seconds).\n fetch('https://...', { next: { revalidate: 10 } })\nSee Revalidating Data for more information.\nGood to know:", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-3", "text": "See Revalidating Data for more information.\nGood to know:\nCaching at the fetch level with revalidate or cache: 'force-cache' stores the data across requests in a shared cache. You should avoid using it for user-specific data (i.e. requests that derive data from cookies() or headers())\nDynamic Data Fetching\nTo fetch fresh data on every fetch request, use the cache: 'no-store' option.\n fetch('https://...', { cache: 'no-store' })\nData Fetching Patterns\nParallel Data Fetching\nTo minimize client-server waterfalls, we recommend this pattern to fetch data in parallel:\napp/artist/[username]/page.tsx import Albums from './albums'\n \nasync function getArtist(username: string) {\n  const res = await fetch(`https://api.example.com/artist/${username}`)\n  return res.json()\n}", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-4", "text": "return res.json()\n}\n \nasync function getArtistAlbums(username: string) {\n  const res = await fetch(`https://api.example.com/artist/${username}/albums`)\n  return res.json()\n}\n \nexport default async function Page({\n  params: { username },\n}: {\n  params: { username: string }\n}) {\n  // Initiate both requests in parallel\n  const artistData = getArtist(username)\n  const albumsData = getArtistAlbums(username)\n \n  // Wait for the promises to resolve\n  const [artist, albums] = await Promise.all([artistData, albumsData])\n \n  return (\n    <>\n      <h1>{artist.name}</h1>\n      <Albums list={albums}></Albums>\n    </>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-5", "text": "</>\n  )\n}\nBy starting the fetch prior to calling await in the Server Component, each request can eagerly start to fetch requests at the same time. This sets the components up so you can avoid waterfalls.\nWe can save time by initiating both requests in parallel, however, the user won't see the rendered result until both promises are resolved.\nTo improve the user experience, you can add a suspense boundary to break up the rendering work and show part of the result as soon as possible:\nartist/[username]/page.tsx import { getArtist, getArtistAlbums, type Album } from './api'\n \nexport default async function Page({\n  params: { username },\n}: {\n  params: { username: string }\n}) {\n  // Initiate both requests in parallel\n  const artistData = getArtist(username)\n  const albumData = getArtistAlbums(username)", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-6", "text": "const albumData = getArtistAlbums(username)\n \n  // Wait for the artist's promise to resolve first\n  const artist = await artistData\n \n  return (\n    <>\n      <h1>{artist.name}</h1>\n      {/* Send the artist information first,\n          and wrap albums in a suspense boundary */}\n      <Suspense fallback={<div>Loading...</div>}>\n        <Albums promise={albumData} />\n      </Suspense>\n    </>\n  )\n}\n \n// Albums Component\nasync function Albums({ promise }: { promise: Promise<Album[]> }) {\n  // Wait for the albums promise to resolve\n  const albums = await promise\n \n  return (\n    <ul>\n      {albums.map((album) => (\n        <li key={album.id}>{album.name}</li>\n      ))}\n    </ul>\n  )", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-7", "text": "))}\n    </ul>\n  )\n}\nTake a look at the preloading pattern for more information on improving components structure.\nSequential Data Fetching\nTo fetch data sequentially, you can fetch directly inside the component that needs it, or you can await the result of fetch inside the component that needs it:\napp/artist/page.tsx // ...\n \nasync function Playlists({ artistID }: { artistID: string }) {\n  // Wait for the playlists\n  const playlists = await getArtistPlaylists(artistID)\n \n  return (\n    <ul>\n      {playlists.map((playlist) => (\n        <li key={playlist.id}>{playlist.name}</li>\n      ))}\n    </ul>\n  )\n}\n \nexport default async function Page({\n  params: { username },\n}: {\n  params: { username: string }\n}) {", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-8", "text": "}: {\n  params: { username: string }\n}) {\n  // Wait for the artist\n  const artist = await getArtist(username)\n \n  return (\n    <>\n      <h1>{artist.name}</h1>\n      <Suspense fallback={<div>Loading...</div>}>\n        <Playlists artistID={artist.id} />\n      </Suspense>\n    </>\n  )\n}\nBy fetching data inside the component, each fetch request and nested segment in the route cannot start fetching data and rendering until the previous request or segment has completed.\nBlocking Rendering in a Route\nBy fetching data in a layout, rendering for all route segments beneath it can only start once the data has finished loading.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-9", "text": "In the pages directory, pages using server-rendering would show the browser loading spinner until getServerSideProps had finished, then render the React component for that page. This can be described as \"all or nothing\" data fetching. Either you had the entire data for your page, or none.\nIn the app directory, you have additional options to explore:\nFirst, you can use loading.js to show an instant loading state from the server while streaming in the result from your data fetching function.\nSecond, you can move data fetching lower in the component tree to only block rendering for the parts of the page that need it. For example, moving data fetching to a specific component rather than fetching it at the root layout.\nWhenever possible, it's best to fetch data in the segment that uses it. This also allows you to show a loading state for only the part of the page that is loading, and not the entire page.\nData Fetching without fetch()", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-10", "text": "Data Fetching without fetch()\nYou might not always have the ability to use and configure fetch requests directly if you're using a third-party library such as an ORM or database client.\nIn cases where you cannot use fetch but still want to control the caching or revalidating behavior of a layout or page, you can rely on the default caching behavior of the segment or use the segment cache configuration.\nDefault Caching Behavior\nAny data fetching libraries that do not use fetch directly will not affect caching of a route, and will be static or dynamic depending on the route segment.\nIf the segment is static (default), the output of the request will be cached and revalidated (if configured) alongside the rest of the segment. If the segment is dynamic, the output of the request will not be cached and will be re-fetched on every request when the segment is rendered.\nGood to know: Dynamic functions like cookies() and headers() will make the route segment dynamic.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "175f38087dac-11", "text": "Good to know: Dynamic functions like cookies() and headers() will make the route segment dynamic.\nSegment Cache Configuration\nAs a temporary solution, until the caching behavior of third-party queries can be configured, you can use segment configuration to customize the cache behavior of the entire segment.\napp/page.tsx import prisma from './lib/prisma'\n \nexport const revalidate = 3600 // revalidate every hour\n \nasync function getPosts() {\n  const posts = await prisma.post.findMany()\n  return posts\n}\n \nexport default async function Page() {\n  const posts = await getPosts()\n  // ...\n}", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/fetching"}
{"id": "2a4a233cbb5c-0", "text": "Caching DataNext.js has built-in support for caching data, both on a per-request basis (recommended) or for an entire route segment.\nPer-request Caching\nfetch()\nBy default, all fetch() requests are cached and deduplicated automatically. This means that if you make the same request twice, the second request will reuse the result from the first request.\napp/page.tsx async function getComments() {\n  const res = await fetch('https://...') // The result is cached\n  return res.json()\n}\n \n// This function is called twice, but the result is only fetched once\nconst comments = await getComments() // cache MISS\n \n// The second call could be anywhere in your application\nconst comments = await getComments() // cache HIT\nRequests are not cached if:", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-1", "text": "const comments = await getComments() // cache HIT\nRequests are not cached if:\nDynamic methods (next/headers, export const POST, or similar) are used and the fetch is a POST request (or uses Authorization or cookie headers)\nfetchCache is configured to skip cache by default\nrevalidate: 0 or cache: 'no-store' is configured on individual fetch\nRequests made using fetch can specify a revalidate option to control the revalidation frequency of the request.\napp/page.tsx export default async function Page() {\n  // revalidate this data every 10 seconds at most\n  const res = await fetch('https://...', { next: { revalidate: 10 } })\n  const data = res.json()\n  // ...\n}\nReact cache()", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-2", "text": "const data = res.json()\n  // ...\n}\nReact cache()\nReact allows you to cache() and deduplicate requests, memoizing the result of the wrapped function call. The same function called with the same arguments will reuse a cached value instead of re-running the function.\nutils/getUser.ts import { cache } from 'react'\n \nexport const getUser = cache(async (id: string) => {\n  const user = await db.user.findUnique({ id })\n  return user\n})\napp/user/[id]/layout.tsx import { getUser } from '@utils/getUser'\n \nexport default async function UserLayout({\n  params: { id },\n}: {\n  params: { id: string }\n}) {\n  const user = await getUser(id)\n  // ...\n}\napp/user/[id]/page.tsx import { getUser } from '@utils/getUser'", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-3", "text": "export default async function Page({\n  params: { id },\n}: {\n  params: { id: string }\n}) {\n  const user = await getUser(id)\n  // ...\n}\nAlthough the getUser() function is called twice in the example above, only one query will be made to the database. This is because getUser() is wrapped in cache(), so the second request can reuse the result from the first request.\nGood to know:\nfetch() caches requests automatically, so you don't need to wrap functions that use fetch() with cache(). See automatic request deduping for more information.\nIn this new model, we recommend fetching data directly in the component that needs it, even if you're requesting the same data in multiple components, rather than passing the data between components as props.\nWe recommend using the server-only package to make sure server data fetching functions are never used on the client.\nPOST requests and cache()", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-4", "text": "POST requests and cache()\nPOST requests are automatically deduplicated when using fetch \u2013 unless they are inside of POST Route Handler or come after reading headers()/cookies(). For example, if you are using GraphQL and POST requests in the above cases, you can use cache to deduplicate requests. The cache arguments must be flat and only include primitives. Deep objects won't match for deduplication.\nutils/getUser.ts import { cache } from 'react'\n \nexport const getUser = cache(async (id: string) => {\n  const res = await fetch('...', { method: 'POST', body: '...' })\n  // ...\n})\nPreload pattern with cache()\nAs a pattern, we suggest optionally exposing a preload() export in utilities or components that do data fetching.\ncomponents/User.tsx import { getUser } from '@utils/getUser'\n \nexport const preload = (id: string) => {", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-5", "text": "export const preload = (id: string) => {\n  // void evaluates the given expression and returns undefined\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void\n  void getUser(id)\n}\nexport default async function User({ id }: { id: string }) {\n  const result = await getUser(id)\n  // ...\n}\nBy calling preload, you can eagerly start fetching data you're likely going to need.\napp/user/[id]/page.tsx import User, { preload } from '@components/User'\n \nexport default async function Page({\n  params: { id },\n}: {\n  params: { id: string }\n}) {\n  preload(id) // starting loading the user data now\n  const condition = await fetchCondition()\n  return condition ? <User id={id} /> : null\n}\nGood to know:", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-6", "text": "}\nGood to know:\nThe preload() function can have any name. It's a pattern, not an API.\nThis pattern is completely optional and something you can use to optimize on a case-by-case basis.\nThis pattern is a further optimization on top of parallel data fetching. Now you don't have to pass promises down as props and can instead rely on the preload pattern.\nCombining cache, preload, and server-only\nYou can combine the cache function, the preload pattern, and the server-only package to create a data fetching utility that can be used throughout your app.\nutils/getUser.ts import { cache } from 'react'\nimport 'server-only'\n \nexport const preload = (id: string) => {\n  void getUser(id)\n}\n \nexport const getUser = cache(async (id: string) => {\n  // ...\n})", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-7", "text": "export const getUser = cache(async (id: string) => {\n  // ...\n})\nWith this approach, you can eagerly fetch data, cache responses, and guarantee that this data fetching only happens on the server.\nThe getUser.ts exports can be used by layouts, pages, or components to give them control over when a user's data is fetched.\nSegment-level Caching\nGood to know: We recommend using per-request caching for improved granularity and control over caching.\nSegment-level caching allows you to cache and revalidate data used in route segments.\nThis mechanism allows different segments of a path to control the cache lifetime of the entire route. Each page.tsx and layout.tsx in the route hierarchy can export a revalidate value that sets the revalidation time for the route.\napp/page.tsx export const revalidate = 60 // revalidate this segment every 60 seconds\nGood to know:", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "2a4a233cbb5c-8", "text": "Good to know:\nIf a page, layout, and fetch request inside components all specify a revalidate frequency, the lowest value of the three will be used.\nAdvanced: You can set fetchCache to 'only-cache' or 'force-cache' to ensure that all fetch requests opt into caching but the revalidation frequency might still be lowered by individual fetch requests. See fetchCache for more information.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/caching"}
{"id": "66d202fb49eb-0", "text": "Revalidating DataNext.js allows you to update specific static routes without needing to rebuild your entire site. Revalidation (also known as Incremental Static Regeneration) allows you to retain the benefits of static while scaling to millions of pages.\nThere are two types of revalidation in Next.js:\nBackground: Revalidates the data at a specific time interval.\nOn-demand: Revalidates the data based on an event such as an update.\nBackground Revalidation\nTo revalidate cached data at a specific interval, you can use the next.revalidate option in fetch() to set the cache lifetime of a resource (in seconds).\n fetch('https://...', { next: { revalidate: 60 } })\nIf you want to revalidate data that does not use fetch (i.e. using an external package or query builder), you can use the route segment config.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/revalidating"}
{"id": "66d202fb49eb-1", "text": "app/page.tsx export const revalidate = 60 // revalidate this page every 60 seconds\nIn addition to fetch, you can also revalidate data using cache.\nHow it works\nWhen a request is made to the route that was statically rendered at build time, it will initially show the cached data.\nAny requests to the route after the initial request and before 60 seconds are also cached and instantaneous.\nAfter the 60-second window, the next request will still show the cached (stale) data.\nNext.js will trigger a regeneration of the data in the background.\nOnce the route generates successfully, Next.js will invalidate the cache and show the updated route. If the background regeneration fails, the old data would still be unaltered.\nWhen a request is made to a route segment that hasn\u2019t been generated, Next.js will dynamically render the route on the first request. Future requests will serve the static route segments from the cache.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/revalidating"}
{"id": "66d202fb49eb-2", "text": "Good to know: Check if your upstream data provider has caching enabled by default. You might need to disable (e.g. useCdn: false), otherwise a revalidation won't be able to pull fresh data to update the ISR cache. Caching can occur at a CDN (for an endpoint being requested) when it returns the Cache-Control header. ISR on Vercel persists the cache globally and handles rollbacks.\nOn-demand Revalidation\nIf you set a revalidate time of 60, all visitors will see the same generated version of your site for one minute. The only way to invalidate the cache is if someone visits the page after the minute has passed.\nThe Next.js App Router supports revalidating content on-demand based on a route or cache tag. This allows you to manually purge the Next.js cache for specific fetches, making it easier to update your site when:\nContent from your headless CMS is created or updated.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/revalidating"}
{"id": "66d202fb49eb-3", "text": "Content from your headless CMS is created or updated.\nEcommerce metadata changes (price, description, category, reviews, etc).\nUsing On-Demand Revalidation\nData can be revalidated on-demand by path (revalidatePath) or by cache tag (revalidateTag).\nFor example, the following fetch adds the cache tag collection:\napp/page.tsx export default async function Page() {\n  const res = await fetch('https://...', { next: { tags: ['collection'] } })\n  const data = await res.json()\n  // ...\n}\nThis cached data can then be revalidated on-demand by calling revalidateTag in a Route Handler.\napp/api/revalidate/route.ts import { NextRequest, NextResponse } from 'next/server'\nimport { revalidateTag } from 'next/cache'\n \nexport async function GET(request: NextRequest) {", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/revalidating"}
{"id": "66d202fb49eb-4", "text": "export async function GET(request: NextRequest) {\n  const tag = request.nextUrl.searchParams.get('tag')\n  revalidateTag(tag)\n  return NextResponse.json({ revalidated: true, now: Date.now() })\n}\nError Handling and Revalidation\nIf an error is thrown while attempting to revalidate data, the last successfully generated data will continue to be served from the cache. On the next subsequent request, Next.js will retry revalidating the data.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/revalidating"}
{"id": "46ac516751e2-0", "text": "Server ActionsServer Actions are an alpha feature in Next.js, built on top of React Actions. They enable server-side data mutations, reduced client-side JavaScript, and progressively enhanced forms. They can be defined inside Server Components and/or called from Client Components:\nWith Server Components:\napp/add-to-cart.js import { cookies } from 'next/headers'\n \n// Server action defined inside a Server Component\nexport default function AddToCart({ productId }) {\n  async function addItem(data) {\n    'use server'\n \n    const cartId = cookies().get('cartId')?.value\n    await saveToDb({ cartId, data })\n  }\n \n  return (\n    <form action={addItem}>\n      <button type=\"submit\">Add to Cart</button>\n    </form>\n  )\n}\nWith Client Components:\napp/actions.js 'use server'\n \nexport async function addItem(data) {", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-1", "text": "app/actions.js 'use server'\n \nexport async function addItem(data) {\n  const cartId = cookies().get('cartId')?.value\n  await saveToDb({ cartId, data })\n}\napp/add-to-cart.js 'use client'\n \nimport { addItem } from './actions.js'\n \n// Server Action being called inside a Client Component\nexport default function AddToCart({ productId }) {\n  return (\n    <form action={addItem}>\n      <button type=\"submit\">Add to Cart</button>\n    </form>\n  )\n}\nGood to know:\nUsing Server Actions will opt into running the React experimental channel.\nReact Actions, useOptimistic, and useFormStatus are not a Next.js or React Server Components specific features.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-2", "text": "Next.js integrates React Actions into the Next.js router, bundler, and caching system, including adding data mutation APIs like revalidateTag and revalidatePath.\nConvention\nYou can enable Server Actions in your Next.js project by enabling the experimental serverActions flag.\nnext.config.js module.exports = {\n  experimental: {\n    serverActions: true,\n  },\n}\nCreation\nServer Actions can be defined in two places:\nInside the component that uses it (Server Components only)\nIn a separate file (Client and Server Components), for reusability. You can define multiple Server Actions in a single file.\nWith Server Components\nCreate a Server Action by defining an asynchronous function with the \"use server\" directive at the top of the function body. This function should have serializable arguments and a serializable return value based on the React Server Components protocol.\napp/server-component.js export default function ServerComponent() {\n  async function myAction() {", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-3", "text": "app/server-component.js export default function ServerComponent() {\n  async function myAction() {\n    'use server'\n    // ...\n  }\n}\nWith Client Components\nIf you're using a Server Action inside a Client Component, create your action in a separate file with the \"use server\" directive at the top of the file. Then, import the Server Action into your Client Component:\napp/actions.js 'use server'\n \nexport async function myAction() {\n  // ...\n}\napp/client-component.js 'use client'\n \nimport { myAction } from './actions'\n \nexport default function ClientComponent() {\n  return (\n    <form action={myAction}>\n      <button type=\"submit\">Add to Cart</button>\n    </form>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-4", "text": "</form>\n  )\n}\nGood to know: When using a top-level \"use server\" directive, all exports below will be considered Server Actions. You can have multiple Server Actions in a single file.\nInvocation\nYou can invoke Server Actions using the following methods:\nUsing action: React's action prop allows invoking a Server Action on a <form> element.\nUsing formAction: React's formAction prop allows handling <button>, <input type=\"submit\">, and <input type=\"image\"> elements in a <form>.\nCustom Invocation with startTransition: Invoke Server Actions without using action or formAction by using startTransition. This method disables Progressive Enhancement.\naction\nYou can use React's action prop to invoke a Server Action on a form element. Server Actions passed with the action prop act as asynchronous side effects in response to user interaction.\napp/add-to-cart.js import { cookies } from 'next/headers'", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-5", "text": "app/add-to-cart.js import { cookies } from 'next/headers'\n \nexport default function AddToCart({ productId }) {\n  async function addItem(data) {\n    'use server'\n \n    const cartId = cookies().get('cartId')?.value\n    await saveToDb({ cartId, data })\n  }\n \n  return (\n    <form action={addItem}>\n      <button type=\"submit\">Add to Cart</button>\n    </form>\n  )\n}\nGood to know: An action is similar to the HTML primitive action\nformAction\nYou can use formAction prop to handle Form Actions on elements such as button, input type=\"submit\", and input type=\"image\". The formAction prop takes precedence over the form's action.\napp/form.js export default function Form() {\n  async function handleSubmit() {\n    'use server'\n    // ...\n  }", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-6", "text": "async function handleSubmit() {\n    'use server'\n    // ...\n  }\n \n  async function submitImage() {\n    'use server'\n    // ...\n  }\n \n  return (\n    <form action={handleSubmit}>\n      <input type=\"text\" name=\"name\" />\n      <input type=\"image\" formAction={submitImage} />\n      <button type=\"submit\">Submit</button>\n    </form>\n  )\n}\nGood to know: A formAction is the HTML primitive formaction. React now allows you to pass functions to this attribute.\nCustom invocation using startTransition\nYou can also invoke Server Actions without using action or formAction. You can achieve this by using startTransition provided by the useTransition hook, which can be useful if you want to use Server Actions outside of forms, buttons, or inputs.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-7", "text": "Good to know: Using startTransition disables the out-of-the-box Progressive Enhancement.\napp/components/example-client-component.js 'use client'\n \nimport { useTransition } from 'react'\nimport { addItem } from '../actions'\n \nfunction ExampleClientComponent({ id }) {\n  let [isPending, startTransition] = useTransition()\n \n  return (\n    <button onClick={() => startTransition(() => addItem(id))}>\n      Add To Cart\n    </button>\n  )\n}\napp/actions.js 'use server'\n \nexport async function addItem(id) {\n  await addItemToDb(id)\n  // Marks all product pages for revalidating\n  revalidatePath('/product/[id]')\n}\nCustom invocation without startTransition\nIf you aren't doing Server Mutations, you can directly pass the function as a prop like any other function.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-8", "text": "app/posts/[id]/page.tsx import kv from '@vercel/kv'\nimport LikeButton from './like-button'\n \nexport default function Page({ params }: { params: { id: string } }) {\n  async function increment() {\n    'use server'\n    await kv.incr(`post:id:${params.id}`)\n  }\n \n  return <LikeButton increment={increment} />\n}\napp/post/[id]/like-button.tsx 'use client'\n \nexport default function LikeButton({\n  increment,\n}: {\n  increment: () => Promise<void>\n}) {\n  return (\n    <button\n      onClick={async () => {\n        await increment()\n      }}\n    >\n      Like\n    </button>\n  )\n}\nEnhancements\nExperimental useOptimistic", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-9", "text": "</button>\n  )\n}\nEnhancements\nExperimental useOptimistic\nThe experimental useOptimistic hook provides a way to implement optimistic updates in your application. Optimistic updates are a technique that enhances user experience by making the app appear more responsive.\nWhen a Server Action is invoked, the UI is updated immediately to reflect the expected outcome, instead of waiting for the Server Action's response.\napp/thread.js 'use client'\n \nimport { experimental_useOptimistic as useOptimistic, useRef } from 'react'\nimport { send } from './actions.js'\n \nexport function Thread({ messages }) {\n  const [optimisticMessages, addOptimisticMessage] = useOptimistic(\n    messages,\n    (state, newMessage) => [...state, { message: newMessage, sending: true }]\n  )\n  const formRef = useRef()\n \n  return (", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-10", "text": ")\n  const formRef = useRef()\n \n  return (\n    <div>\n      {optimisticMessages.map((m) => (\n        <div>\n          {m.message}\n          {m.sending ? 'Sending...' : ''}\n        </div>\n      ))}\n      <form\n        action={async (formData) => {\n          const message = formData.get('message')\n          formRef.current.reset()\n          addOptimisticMessage(message)\n          await send(message)\n        }}\n        ref={formRef}\n      >\n        <input type=\"text\" name=\"message\" />\n      </form>\n    </div>\n  )\n}\nExperimental useFormStatus\nThe experimental useFormStatus hook can be used within Form Actions, and provides the pending property.\napp/form.js 'use client'", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-11", "text": "app/form.js 'use client'\n \nimport { experimental_useFormStatus as useFormStatus } from 'react-dom'\n \nfunction Submit() {\n  const { pending } = useFormStatus()\n \n  return (\n    <input\n      type=\"submit\"\n      className={pending ? 'button-pending' : 'button-normal'}\n      disabled={pending}\n    >\n      Submit\n    </input>\n  )\n}\nProgressive Enhancement\nProgressive Enhancement allows a <form> to function properly without JavaScript, or with JavaScript disabled. This allows users to interact with the form and submit data even if the JavaScript for the form hasn't been loaded yet or if it fails to load.\nBoth Server Form Actions and Client Form Actions support Progressive Enhancement, using one of two strategies:\nIf a Server Action is passed directly to a <form>, the form is interactive even if JavaScript is disabled.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-12", "text": "If a Client Action is passed to a <form>, the form is still interactive, but the action will be placed in a queue until the form has hydrated. The <form> is prioritized with Selective Hydration, so it happens quickly.\napp/components/example-client-component.js 'use client'\n \nimport { useState } from 'react'\nimport { handleSubmit } from './actions.js'\n \nexport default function ExampleClientComponent({ myAction }) {\n  const [input, setInput] = useState()\n \n  return (\n    <form action={handleSubmit} onChange={(e) => setInput(e.target.value)}>\n      {/* ... */}\n    </form>\n  )\n}\nIn both cases, the form is interactive before hydration occurs. Although Server Actions have the additional benefit of not relying on client JavaScript, you can still compose additional behavior with Client Actions where desired without sacrificing interactivity.\nSize Limitation", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-13", "text": "Size Limitation\nBy default, the maximum size of the request body sent to a Server Action is 1MB. This prevents large amounts of data being sent to the server, which consumes a lot of server resource to parse.\nHowever, you can configure this limit using the experimental serverActionsBodySizeLimit option. It can take the number of bytes or any string format supported by bytes, for example 1000, '500kb' or '3mb'.\nnext.config.js module.exports = {\n  experimental: {\n    serverActions: true,\n    serverActionsBodySizeLimit: '2mb',\n  },\n}\nExamples\nUsage with Client Components\nImport\nServer Actions cannot be defined within Client Components, but they can be imported. To use Server Actions in Client Components, you can import the action from a file containing a top-level \"use server\" directive.\napp/actions.js 'use server'\n \nexport async function addItem() {", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-14", "text": "app/actions.js 'use server'\n \nexport async function addItem() {\n  // ...\n}\napp/components/example-client-component.js 'use client'\n \nimport { useTransition } from 'react'\nimport { addItem } from '../actions'\n \nfunction ExampleClientComponent({ id }) {\n  let [isPending, startTransition] = useTransition()\n \n  return (\n    <button onClick={() => startTransition(() => addItem(id))}>\n      Add To Cart\n    </button>\n  )\n}\nProps\nAlthough importing Server Actions is recommended, in some cases you might want to pass down a Server Action to a Client Component as a prop.\nFor example, you might want to use a dynamically generated value within the action. In that case, passing a Server Action down as a prop might be a viable solution.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-15", "text": "app/components/example-server-component.js import { ExampleClientComponent } from './components/example-client-component.js'\n \nfunction ExampleServerComponent({ id }) {\n  async function updateItem(data) {\n    'use server'\n    modifyItem({ id, data })\n  }\n \n  return <ExampleClientComponent updateItem={updateItem} />\n}\napp/components/example-client-component.js 'use client'\n \nfunction ExampleClientComponent({ updateItem }) {\n  async function action(formData) {\n    await updateItem(formData)\n  }\n \n  return (\n    <form action={action}>\n      <input type=\"text\" name=\"name\" />\n      <button type=\"submit\">Update Item</button>\n    </form>\n  )\n}\nOn-demand Revalidation", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-16", "text": "</form>\n  )\n}\nOn-demand Revalidation\nServer Actions can be used to revalidate data on-demand by path (revalidatePath) or by cache tag (revalidateTag).\n import { revalidateTag } from 'next/cache'\n \nasync function revalidate() {\n  'use server'\n  revalidateTag('blog-posts')\n}\nValidation\nThe data passed to a Server Action can be validated or sanitized before invoking the action. For example, you can create a wrapper function that receives the action as its argument, and returns a function that invokes the action if it's valid.\napp/actions.js 'use server'\n \nimport { withValidate } from 'lib/form-validation'\n \nexport const action = withValidate((data) => {\n  // ...\n})\nlib/form-validation.js export function withValidate(action) {\n  return async (formData) => {\n    'use server'", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-17", "text": "return async (formData) => {\n    'use server'\n \n    const isValidData = verifyData(formData)\n \n    if (!isValidData) {\n      throw new Error('Invalid input.')\n    }\n \n    const data = process(formData)\n    return action(data)\n  }\n}\nUsing headers\nYou can read incoming request headers such as cookies and headers within a Server Action.\n import { cookies } from 'next/headers'\n \nasync function addItem(data) {\n  'use server'\n \n  const cartId = cookies().get('cartId')?.value\n \n  await saveToDb({ cartId, data })\n}\nAdditionally, you can modify cookies within a Server Action.\n import { cookies } from 'next/headers';\n \nasync function create(data) {\n  'use server';\n \n  const cart = await createCart():", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-18", "text": "'use server';\n \n  const cart = await createCart():\n  cookies().set('cartId', cart.id)\n  // or\n  cookies().set({\n    name: 'cartId',\n    value: cart.id,\n    httpOnly: true,\n    path: '/'\n  })\n}\nGlossary\nActions\nActions are an experimental feature in React, allowing you to run async code in response to a user interaction.\nActions are not Next.js or React Server Components specific, however, they are not yet available in the stable version of React. When using Actions through Next.js, you are opting into using the React experimental channel.\nActions are defined through the action prop on an element. Typically when building HTML forms, you pass a URL to the action prop. With Actions, React now allows you to pass a function directly.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "46ac516751e2-19", "text": "React also provides built-in solutions for optimistic updates with Actions. It's important to note new patterns are still being developed and new APIs may still be added.\nForm Actions\nActions integrated into the web standard <form> API, and enable out-of-the-box progressive enhancement and loading states. Similar to the HTML primitive formaction.\nServer Functions\nFunctions that run on the server, but can be called on the client.\nServer Actions\nServer Functions called as an action.\nServer Actions can be progressively enhanced by passing them to a form element's action prop. The form is interactive before any client-side JavaScript has loaded. This means React hydration is not required for the form to submit.\nServer Mutations\nServer Actions that mutates your data and calls redirect, revalidatePath, or revalidateTag.", "source": "https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions"}
{"id": "64d4e2b4532d-0", "text": "CSS Modules\nNext.js has built-in support for CSS Modules using the .module.css extension.\nCSS Modules locally scope CSS by automatically creating a unique class name. This allows you to use the same class name in different files without worrying about collisions. This behavior makes CSS Modules the ideal way to include component-level CSS.\nExample\nCSS Modules can be imported into any file inside the app directory:app/dashboard/layout.tsx import styles from './styles.module.css'\n \nexport default function DashboardLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return <section className={styles.dashboard}>{children}</section>\n}app/dashboard/styles.module.css .dashboard {\n  padding: 24px;\n}\nCSS Modules are an optional feature and are only enabled for files with the .module.css extension.\nRegular <link> stylesheets and global CSS files are still supported.", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-modules"}
{"id": "64d4e2b4532d-1", "text": "Regular <link> stylesheets and global CSS files are still supported.\nIn production, all CSS Module files will be automatically concatenated into many minified and code-split .css files.\nThese .css files represent hot execution paths in your application, ensuring the minimal amount of CSS is loaded for your application to paint.\nGlobal Styles\nGlobal styles can be imported into any layout, page, or component inside the app directory.\nGood to know: This is different from the pages directory, where you can only import global styles inside the _app.js file.\nFor example, consider a stylesheet named app/global.css: body {\n  padding: 20px 20px 60px;\n  max-width: 680px;\n  margin: 0 auto;\n}Inside the root layout (app/layout.js), import the global.css stylesheet to apply the styles to every route in your application:app/layout.tsx // These styles apply to every route in the application", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-modules"}
{"id": "64d4e2b4532d-2", "text": "import './global.css'\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n    </html>\n  )\n}\nExternal Stylesheets\nStylesheets published by external packages can be imported anywhere in the app directory, including colocated components:app/layout.tsx import 'bootstrap/dist/css/bootstrap.css'\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body className=\"container\">{children}</body>\n    </html>\n  )\n}\nGood to know: External stylesheets must be directly imported from an npm package or downloaded and colocated with your codebase. You cannot use <link rel=\"stylesheet\" />.\nAdditional Features", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-modules"}
{"id": "64d4e2b4532d-3", "text": "Additional Features\nNext.js includes additional features to improve the authoring experience of adding styles:\nWhen running locally with next dev, local stylesheets (either global or CSS modules) will take advantage of Fast Refresh to instantly reflect changes as edits are saved.\nWhen building for production with next build, CSS files will be bundled into fewer minified .css files to reduce the number of network requests needed to retrieve styles.\nIf you disable JavaScript, styles will still be loaded in the production build (next start). However, JavaScript is still required for next dev to enable Fast Refresh.", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-modules"}
{"id": "64e8c07c73bb-0", "text": "Tailwind CSS\nTailwind CSS is a utility-first CSS framework that works exceptionally well with Next.js.\nInstalling Tailwind\nInstall the Tailwind CSS packages and run the init command to generate both the tailwind.config.js and postcss.config.js files:\nTerminal npm install -D tailwindcss postcss autoprefixer\nnpx tailwindcss init -p\nConfiguring Tailwind\nInside tailwind.config.js, add paths to the files that will use Tailwind CSS class names:\ntailwind.config.js /** @type {import('tailwindcss').Config} */\nmodule.exports = {\n  content: [\n    './app/**/*.{js,ts,jsx,tsx,mdx}', // Note the addition of the `app` directory.\n    './pages/**/*.{js,ts,jsx,tsx,mdx}',\n    './components/**/*.{js,ts,jsx,tsx,mdx}',", "source": "https://nextjs.org/docs/app/building-your-application/styling/tailwind-css"}
{"id": "64e8c07c73bb-1", "text": "'./components/**/*.{js,ts,jsx,tsx,mdx}',\n \n    // Or if using `src` directory:\n    './src/**/*.{js,ts,jsx,tsx,mdx}',\n  ],\n  theme: {\n    extend: {},\n  },\n  plugins: [],\n}\nYou do not need to modify postcss.config.js.\nImporting Styles\nAdd the Tailwind CSS directives that Tailwind will use to inject its generated styles to a Global Stylesheet in your application, for example:app/globals.css @tailwind base;\n@tailwind components;\n@tailwind utilities;Inside the root layout (app/layout.tsx), import the globals.css stylesheet to apply the styles to every route in your application.app/layout.tsx import type { Metadata } from 'next'\n \n// These styles apply to every route in the application\nimport './globals.css'", "source": "https://nextjs.org/docs/app/building-your-application/styling/tailwind-css"}
{"id": "64e8c07c73bb-2", "text": "// These styles apply to every route in the application\nimport './globals.css'\n \nexport const metadata: Metadata = {\n  title: 'Create Next App',\n  description: 'Generated by create next app',\n}\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n    </html>\n  )\n}Using Classes\nAfter installing Tailwind CSS and adding the global styles, you can use Tailwind's utility classes in your application.app/page.tsx export default function Page() {\n  return <h1 className=\"text-3xl font-bold underline\">Hello, Next.js!</h1>\n}\nUsage with Turbopack\nAs of Next.js 13.1, Tailwind CSS and PostCSS are supported with Turbopack.", "source": "https://nextjs.org/docs/app/building-your-application/styling/tailwind-css"}
{"id": "8945e7d1627d-0", "text": "CSS-in-JS\nWarning: CSS-in-JS libraries which require runtime JavaScript are not currently supported in Server Components. Using CSS-in-JS with newer React features like Server Components and Streaming requires library authors to support the latest version of React, including concurrent rendering.\nWe're working with the React team on upstream APIs to handle CSS and JavaScript assets with support for React Server Components and streaming architecture.\nThe following libraries are supported in Client Components in the app directory (alphabetical):\nkuma-ui\n@mui/material\npandacss\nstyled-jsx\nstyled-components\nstyle9\ntamagui\ntss-react\nvanilla-extract\nThe following are currently working on support:\nemotion\nGood to know: We're testing out different CSS-in-JS libraries and we'll be adding more examples for libraries that support React 18 features and/or the app directory.", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-in-js"}
{"id": "8945e7d1627d-1", "text": "If you want to style Server Components, we recommend using CSS Modules or other solutions that output CSS files, like PostCSS or Tailwind CSS.Configuring CSS-in-JS in app\nConfiguring CSS-in-JS is a three-step opt-in process that involves:\nA style registry to collect all CSS rules in a render.\nThe new useServerInsertedHTML hook to inject rules before any content that might use them.\nA Client Component that wraps your app with the style registry during initial server-side rendering.\nstyled-jsx\nUsing styled-jsx in Client Components requires using v5.1.0. First, create a new registry:app/registry.tsx 'use client'\n \nimport React, { useState } from 'react'\nimport { useServerInsertedHTML } from 'next/navigation'\nimport { StyleRegistry, createStyleRegistry } from 'styled-jsx'\n \nexport default function StyledJsxRegistry({\n  children,", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-in-js"}
{"id": "8945e7d1627d-2", "text": "export default function StyledJsxRegistry({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  // Only create stylesheet once with lazy initial state\n  // x-ref: https://reactjs.org/docs/hooks-reference.html#lazy-initial-state\n  const [jsxStyleRegistry] = useState(() => createStyleRegistry())\n \n  useServerInsertedHTML(() => {\n    const styles = jsxStyleRegistry.styles()\n    jsxStyleRegistry.flush()\n    return <>{styles}</>\n  })\n \n  return <StyleRegistry registry={jsxStyleRegistry}>{children}</StyleRegistry>\n}Then, wrap your root layout with the registry:app/layout.tsx import StyledJsxRegistry from './registry'\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html>\n      <body>", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-in-js"}
{"id": "8945e7d1627d-3", "text": "}) {\n  return (\n    <html>\n      <body>\n        <StyledJsxRegistry>{children}</StyledJsxRegistry>\n      </body>\n    </html>\n  )\n}View an example here.Styled Components\nBelow is an example of how to configure styled-components@v6.0.0-rc.1 or greater:First, use the styled-components API to create a global registry component to collect all CSS style rules generated during a render, and a function to return those rules. Then use the useServerInsertedHTML hook to inject the styles collected in the registry into the <head> HTML tag in the root layout.lib/registry.tsx 'use client'\n \nimport React, { useState } from 'react'\nimport { useServerInsertedHTML } from 'next/navigation'\nimport { ServerStyleSheet, StyleSheetManager } from 'styled-components'\n \nexport default function StyledComponentsRegistry({", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-in-js"}
{"id": "8945e7d1627d-4", "text": "export default function StyledComponentsRegistry({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  // Only create stylesheet once with lazy initial state\n  // x-ref: https://reactjs.org/docs/hooks-reference.html#lazy-initial-state\n  const [styledComponentsStyleSheet] = useState(() => new ServerStyleSheet())\n \n  useServerInsertedHTML(() => {\n    const styles = styledComponentsStyleSheet.getStyleElement()\n    styledComponentsStyleSheet.instance.clearTag()\n    return <>{styles}</>\n  })\n \n  if (typeof window !== 'undefined') return <>{children}</>\n \n  return (\n    <StyleSheetManager sheet={styledComponentsStyleSheet.instance}>\n      {children}\n    </StyleSheetManager>\n  )\n}Wrap the children of the root layout with the style registry component:app/layout.tsx import StyledComponentsRegistry from './lib/registry'", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-in-js"}
{"id": "8945e7d1627d-5", "text": "export default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html>\n      <body>\n        <StyledComponentsRegistry>{children}</StyledComponentsRegistry>\n      </body>\n    </html>\n  )\n}View an example here.\nGood to know:\nDuring server rendering, styles will be extracted to a global registry and flushed to the <head> of your HTML. This ensures the style rules are placed before any content that might use them. In the future, we may use an upcoming React feature to determine where to inject the styles.\nDuring streaming, styles from each chunk will be collected and appended to existing styles. After client-side hydration is complete, styled-components will take over as usual and inject any further dynamic styles.", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-in-js"}
{"id": "8945e7d1627d-6", "text": "We specifically use a Client Component at the top level of the tree for the style registry because it's more efficient to extract CSS rules this way. It avoids re-generating styles on subsequent server renders, and prevents them from being sent in the Server Component payload.", "source": "https://nextjs.org/docs/app/building-your-application/styling/css-in-js"}
{"id": "af7a2f69c782-0", "text": "Sass\nNext.js has built-in support for Sass using both the .scss and .sass extensions. You can use component-level Sass via CSS Modules and the .module.scssor .module.sass extension.\nFirst, install sass:\nTerminal npm install --save-dev sass\nGood to know:\nSass supports two different syntax, each with their own extension.\nThe .scss extension requires you use the SCSS syntax,\nwhile the .sass extension requires you use the Indented Syntax (\"Sass\").\nIf you're not sure which to choose, start with the .scss extension which is a superset of CSS, and doesn't require you learn the\nIndented Syntax (\"Sass\").\nCustomizing Sass Options\nIf you want to configure the Sass compiler, use sassOptions in next.config.js.\nnext.config.js const path = require('path')\n \nmodule.exports = {\n  sassOptions: {", "source": "https://nextjs.org/docs/app/building-your-application/styling/sass"}
{"id": "af7a2f69c782-1", "text": "module.exports = {\n  sassOptions: {\n    includePaths: [path.join(__dirname, 'styles')],\n  },\n}\nSass Variables\nNext.js supports Sass variables exported from CSS Module files.\nFor example, using the exported primaryColor Sass variable:\napp/variables.module.scss $primary-color: #64ff00;\n \n:export {\n  primaryColor: $primary-color;\n}\napp/page.js // maps to root `/` URL\n \nimport variables from './variables.module.scss'\n \nexport default function Page() {\n  return <h1 style={{ color: variables.primaryColor }}>Hello, Next.js!</h1>\n}", "source": "https://nextjs.org/docs/app/building-your-application/styling/sass"}
{"id": "f6dc9a7dd197-0", "text": "Image Optimization\nExamples\nImage Component\nAccording to Web Almanac, images account for a huge portion of the typical website\u2019s page weight and can have a sizable impact on your website's LCP performance.\nThe Next.js Image component extends the HTML <img> element with features for automatic image optimization:\nSize Optimization: Automatically serve correctly sized images for each device, using modern image formats like WebP and AVIF.\nVisual Stability: Prevent layout shift automatically when images are loading.\nFaster Page Loads: Images are only loaded when they enter the viewport using native browser lazy loading, with optional blur-up placeholders.\nAsset Flexibility: On-demand image resizing, even for images stored on remote servers\n\ud83c\udfa5 Watch: Learn more about how to use next/image \u2192 YouTube (9 minutes).\nUsage\n import Image from 'next/image'\nYou can then define the src for your image (either local or remote).\nLocal Images", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-1", "text": "You can then define the src for your image (either local or remote).\nLocal Images\nTo use a local image, import your .jpg, .png, or .webp image files.\nNext.js will automatically determine the width and height of your image based on the imported file. These values are used to prevent Cumulative Layout Shift while your image is loading.\napp/page.js import Image from 'next/image'\nimport profilePic from './me.png'\n \nexport default function Page() {\n  return (\n    <Image\n      src={profilePic}\n      alt=\"Picture of the author\"\n      // width={500} automatically provided\n      // height={500} automatically provided\n      // blurDataURL=\"data:...\" automatically provided\n      // placeholder=\"blur\" // Optional blur-up while loading\n    />\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-2", "text": "/>\n  )\n}\nWarning: Dynamic await import() or require() are not supported. The import must be static so it can be analyzed at build time.\nRemote Images\nTo use a remote image, the src property should be a URL string.\nSince Next.js does not have access to remote files during the build process, you'll need to provide the width, height and optional blurDataURL props manually.\nThe width and height attributes are used to infer the correct aspect ratio of image and avoid layout shift from the image loading in. The width and height do not determine the rendered size of the image file. Learn more about Image Sizing.\napp/page.js import Image from 'next/image'\n \nexport default function Page() {\n  return (\n    <Image\n      src=\"https://s3.amazonaws.com/my-bucket/profile.png\"\n      alt=\"Picture of the author\"\n      width={500}\n      height={500}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-3", "text": "width={500}\n      height={500}\n    />\n  )\n}\nTo safely allow optimizing images, define a list of supported URL patterns in next.config.js. Be as specific as possible to prevent malicious usage. For example, the following configuration will only allow images from a specific AWS S3 bucket:\nnext.config.js module.exports = {\n  images: {\n    remotePatterns: [\n      {\n        protocol: 'https',\n        hostname: 's3.amazonaws.com',\n        port: '',\n        pathname: '/my-bucket/**',\n      },\n    ],\n  },\n}\nLearn more about remotePatterns configuration. If you want to use relative URLs for the image src, use a loader.\nDomains", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-4", "text": "Domains\nSometimes you may want to optimize a remote image, but still use the built-in Next.js Image Optimization API. To do this, leave the loader at its default setting and enter an absolute URL for the Image src prop.\nTo protect your application from malicious users, you must define a list of remote hostnames you intend to use with the next/image component.\nLearn more about remotePatterns configuration.\nLoaders\nNote that in the example earlier, a partial URL (\"/me.png\") is provided for a remote image. This is possible because of the loader architecture.\nA loader is a function that generates the URLs for your image. It modifies the provided src, and generates multiple URLs to request the image at different sizes. These multiple URLs are used in the automatic srcset generation, so that visitors to your site will be served an image that is the right size for their viewport.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-5", "text": "The default loader for Next.js applications uses the built-in Image Optimization API, which optimizes images from anywhere on the web, and then serves them directly from the Next.js web server. If you would like to serve your images directly from a CDN or image server, you can write your own loader function with a few lines of JavaScript.\nYou can define a loader per-image with the loader prop, or at the application level with the loaderFile configuration.\nPriority\nYou should add the priority property to the image that will be the Largest Contentful Paint (LCP) element for each page. Doing so allows Next.js to specially prioritize the image for loading (e.g. through preload tags or priority hints), leading to a meaningful boost in LCP.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-6", "text": "The LCP element is typically the largest image or text block visible within the viewport of the page. When you run next dev, you'll see a console warning if the LCP element is an <Image> without the priority property.\nOnce you've identified the LCP image, you can add the property like this:\napp/page.js import Image from 'next/image'\nimport profilePic from '../public/me.png'\n \nexport default function Page() {\n  return <Image src={profilePic} alt=\"Picture of the author\" priority />\n}\nSee more about priority in the next/image component documentation.\nImage Sizing", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-7", "text": "}\nSee more about priority in the next/image component documentation.\nImage Sizing\nOne of the ways that images most commonly hurt performance is through layout shift, where the image pushes other elements around on the page as it loads in. This performance problem is so annoying to users that it has its own Core Web Vital, called Cumulative Layout Shift. The way to avoid image-based layout shifts is to always size your images. This allows the browser to reserve precisely enough space for the image before it loads.\nBecause next/image is designed to guarantee good performance results, it cannot be used in a way that will contribute to layout shift, and must be sized in one of three ways:\nAutomatically, using a static import\nExplicitly, by including a width and height property\nImplicitly, by using fill which causes the image to expand to fill its parent element.\nWhat if I don't know the size of my images?", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-8", "text": "What if I don't know the size of my images?\nIf you are accessing images from a source without knowledge of the images' sizes, there are several things you can do:\nUse fill\nThe fill prop allows your image to be sized by its parent element. Consider using CSS to give the image's parent element space on the page along sizes prop to match any media query break points. You can also use object-fit with fill, contain, or cover, and object-position to define how the image should occupy that space.\nNormalize your images\nIf you're serving images from a source that you control, consider modifying your image pipeline to normalize the images to a specific size.\nModify your API calls\nIf your application is retrieving image URLs using an API call (such as to a CMS), you may be able to modify the API call to return the image dimensions along with the URL.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-9", "text": "If none of the suggested methods works for sizing your images, the next/image component is designed to work well on a page alongside standard <img> elements.\nStyling\nStyling the Image component is similar to styling a normal <img> element, but there are a few guidelines to keep in mind:\nUse className or style, not styled-jsx.\nIn most cases, we recommend using the className prop. This can be an imported CSS Module, a global stylesheet, etc.\nYou can also use the style prop to assign inline styles.\nYou cannot use styled-jsx because it's scoped to the current component (unless you mark the style as global).\nWhen using fill, the parent element must have position: relative\nThis is necessary for the proper rendering of the image element in that layout mode.\nWhen using fill, the parent element must have display: block\nThis is the default for <div> elements but should be specified otherwise.\nExamples\nResponsive", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-10", "text": "This is the default for <div> elements but should be specified otherwise.\nExamples\nResponsive\n import Image from 'next/image'\nimport mountains from '../public/mountains.jpg'\n \nexport default function Responsive() {\n  return (\n    <div style={{ display: 'flex', flexDirection: 'column' }}>\n      <Image\n        alt=\"Mountains\"\n        // Importing an image will\n        // automatically set the width and height\n        src={mountains}\n        sizes=\"100vw\"\n        // Make the image display full width\n        style={{\n          width: '100%',\n          height: 'auto',\n        }}\n      />\n    </div>\n  )\n}\nFill Container\n import Image from 'next/image'\nimport mountains from '../public/mountains.jpg'\n \nexport default function Fill() {\n  return (\n    <div\n      style={{", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-11", "text": "export default function Fill() {\n  return (\n    <div\n      style={{\n        display: 'grid',\n        gridGap: '8px',\n        gridTemplateColumns: 'repeat(auto-fit, minmax(400px, auto))',\n      }}\n    >\n      <div style={{ position: 'relative', height: '400px' }}>\n        <Image\n          alt=\"Mountains\"\n          src={mountains}\n          fill\n          sizes=\"(min-width: 808px) 50vw, 100vw\"\n          style={{\n            objectFit: 'cover', // cover, contain, none\n          }}\n        />\n      </div>\n      {/* And more images in the grid... */}\n    </div>\n  )\n}\nBackground Image\n import Image from 'next/image'\nimport mountains from '../public/mountains.jpg'\n \nexport default function Background() {", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "f6dc9a7dd197-12", "text": "import mountains from '../public/mountains.jpg'\n \nexport default function Background() {\n  return (\n    <Image\n      alt=\"Mountains\"\n      src={mountains}\n      placeholder=\"blur\"\n      quality={100}\n      fill\n      sizes=\"100vw\"\n      style={{\n        objectFit: 'cover',\n      }}\n    />\n  )\n}\nFor examples of the Image component used with the various styles, see the Image Component Demo.\nOther Properties\nView all properties available to the next/image component.\nConfiguration\nThe next/image component and Next.js Image Optimization API can be configured in the next.config.js file. These configurations allow you to enable remote images, define custom image breakpoints, change caching behavior and more.\nRead the full image configuration documentation for more information.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/images"}
{"id": "43a365f70a81-0", "text": "Font Optimization\nnext/font will automatically optimize your fonts (including custom fonts) and remove external network requests for improved privacy and performance.\n\ud83c\udfa5 Watch: Learn more about how to use next/font \u2192 YouTube (6 minutes).\nnext/font includes built-in automatic self-hosting for any font file. This means you can optimally load web fonts with zero layout shift, thanks to the underlying CSS size-adjust property used.\nThis new font system also allows you to conveniently use all Google Fonts with performance and privacy in mind. CSS and font files are downloaded at build time and self-hosted with the rest of your static assets. No requests are sent to Google by the browser.\nGoogle Fonts\nAutomatically self-host any Google Font. Fonts are included in the deployment and served from the same domain as your deployment. No requests are sent to Google by the browser.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-1", "text": "Get started by importing the font you would like to use from next/font/google as a function. We recommend using variable fonts for the best performance and flexibility.\napp/layout.tsx import { Inter } from 'next/font/google'\n \n// If loading a variable font, you don't need to specify the font weight\nconst inter = Inter({\n  subsets: ['latin'],\n  display: 'swap',\n})\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\" className={inter.className}>\n      <body>{children}</body>\n    </html>\n  )\n}If you can't use a variable font, you will need to specify a weight:app/layout.tsx import { Roboto } from 'next/font/google'\n \nconst roboto = Roboto({\n  weight: '400',", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-2", "text": "const roboto = Roboto({\n  weight: '400',\n  subsets: ['latin'],\n  display: 'swap',\n})\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\" className={roboto.className}>\n      <body>{children}</body>\n    </html>\n  )\n}\nYou can specify multiple weights and/or styles by using an array:\napp/layout.js const roboto = Roboto({\n  weight: ['400', '700'],\n  style: ['normal', 'italic'],\n  subsets: ['latin'],\n  display: 'swap',\n})\nGood to know: Use an underscore (_) for font names with multiple words. E.g. Roboto Mono should be imported as Roboto_Mono.\nSpecifying a subset", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-3", "text": "Specifying a subset\nGoogle Fonts are automatically subset. This reduces the size of the font file and improves performance. You'll need to define which of these subsets you want to preload. Failing to specify any subsets while preload is true will result in a warning.\nThis can be done by adding it to the function call:\napp/layout.tsx const inter = Inter({ subsets: ['latin'] })\nView the Font API Reference for more information.\nUsing Multiple Fonts\nYou can import and use multiple fonts in your application. There are two approaches you can take.\nThe first approach is to create a utility function that exports a font, imports it, and applies its className where needed. This ensures the font is preloaded only when it's rendered:\napp/fonts.ts import { Inter, Roboto_Mono } from 'next/font/google'\n \nexport const inter = Inter({\n  subsets: ['latin'],\n  display: 'swap',\n})", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-4", "text": "subsets: ['latin'],\n  display: 'swap',\n})\n \nexport const roboto_mono = Roboto_Mono({\n  subsets: ['latin'],\n  display: 'swap',\n})\napp/layout.tsx import { inter } from './fonts'\n \nexport default function Layout({ children }: { children: React.ReactNode }) {\n  return (\n    <html lang=\"en\" className={inter.className}>\n      <body>\n        <div>{children}</div>\n      </body>\n    </html>\n  )\n}app/page.tsx import { roboto_mono } from './fonts'\n \nexport default function Page() {\n  return (\n    <>\n      <h1 className={roboto_mono.className}>My page</h1>\n    </>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-5", "text": "</>\n  )\n}\nIn the example above, Inter will be applied globally, and Roboto Mono can be imported and applied as needed.\nAlternatively, you can create a CSS variable and use it with your preferred CSS solution:\napp/layout.tsx import { Inter, Roboto_Mono } from 'next/font/google'\nimport styles from './global.css'\n \nconst inter = Inter({\n  subsets: ['latin'],\n  variable: '--font-inter',\n  display: 'swap',\n})\n \nconst roboto_mono = Roboto_Mono({\n  subsets: ['latin'],\n  variable: '--font-roboto-mono',\n  display: 'swap',\n})\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-6", "text": "children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\" className={`${inter.variable} ${roboto_mono.variable}`}>\n      <body>\n        <h1>My App</h1>\n        <div>{children}</div>\n      </body>\n    </html>\n  )\n}\napp/global.css html {\n  font-family: var(--font-inter);\n}\n \nh1 {\n  font-family: var(--font-roboto-mono);\n}\nIn the example above, Inter will be applied globally, and any <h1> tags will be styled with Roboto Mono.\nRecommendation: Use multiple fonts conservatively since each new font is an additional resource the client has to download.\nLocal Fonts", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-7", "text": "Local Fonts\nImport next/font/local and specify the src of your local font file. We recommend using variable fonts for the best performance and flexibility.\napp/layout.tsx import localFont from 'next/font/local'\n \n// Font files can be colocated inside of `app`\nconst myFont = localFont({\n  src: './my-font.woff2',\n  display: 'swap',\n})\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\" className={myFont.className}>\n      <body>{children}</body>\n    </html>\n  )\n}\nIf you want to use multiple files for a single font family, src can be an array:\n const roboto = localFont({\n  src: [\n    {\n      path: './Roboto-Regular.woff2',", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-8", "text": "src: [\n    {\n      path: './Roboto-Regular.woff2',\n      weight: '400',\n      style: 'normal',\n    },\n    {\n      path: './Roboto-Italic.woff2',\n      weight: '400',\n      style: 'italic',\n    },\n    {\n      path: './Roboto-Bold.woff2',\n      weight: '700',\n      style: 'normal',\n    },\n    {\n      path: './Roboto-BoldItalic.woff2',\n      weight: '700',\n      style: 'italic',\n    },\n  ],\n})\nView the Font API Reference for more information.\nWith Tailwind CSS\nnext/font can be used with Tailwind CSS through a CSS variable.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-9", "text": "With Tailwind CSS\nnext/font can be used with Tailwind CSS through a CSS variable.\nIn the example below, we use the font Inter from next/font/google (you can use any font from Google or Local Fonts). Load your font with the variable option to define your CSS variable name and assign it to inter. Then, use inter.variable to add the CSS variable to your HTML document.\napp/layout.tsx import { Inter, Roboto_Mono } from 'next/font/google'\n \nconst inter = Inter({\n  subsets: ['latin'],\n  display: 'swap',\n  variable: '--font-inter',\n})\n \nconst roboto_mono = Roboto_Mono({\n  subsets: ['latin'],\n  display: 'swap',\n  variable: '--font-roboto-mono',\n})\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-10", "text": "children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\" className={`${inter.variable} ${roboto_mono.variable}`}>\n      <body>{children}</body>\n    </html>\n  )\n}\nFinally, add the CSS variable to your Tailwind CSS config:\ntailwind.config.js /** @type {import('tailwindcss').Config} */\nmodule.exports = {\n  content: [\n    './pages/**/*.{js,ts,jsx,tsx}',\n    './components/**/*.{js,ts,jsx,tsx}',\n    './app/**/*.{js,ts,jsx,tsx}',\n  ],\n  theme: {\n    extend: {\n      fontFamily: {\n        sans: ['var(--font-inter)'],\n        mono: ['var(--font-roboto-mono)'],\n      },\n    },\n  },", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-11", "text": "},\n    },\n  },\n  plugins: [],\n}\nYou can now use the font-sans and font-mono utility classes to apply the font to your elements.\nPreloading\nWhen a font function is called on a page of your site, it is not globally available and preloaded on all routes. Rather, the font is only preloaded on the related routes based on the type of file where it is used:\nIf it's a unique page, it is preloaded on the unique route for that page.\nIf it's a layout, it is preloaded on all the routes wrapped by the layout.\nIf it's the root layout, it is preloaded on all routes.\nReusing fonts", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "43a365f70a81-12", "text": "If it's the root layout, it is preloaded on all routes.\nReusing fonts\nEvery time you call the localFont or Google font function, that font is hosted as one instance in your application. Therefore, if you load the same font function in multiple files, multiple instances of the same font are hosted. In this situation, it is recommended to do the following:\nCall the font loader function in one shared file\nExport it as a constant\nImport the constant in each file where you would like to use this font", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/fonts"}
{"id": "995394ed8592-0", "text": "Script Optimization\nLayout Scripts\nTo load a third-party script for multiple routes, import next/script and include the script directly in your layout component:app/dashboard/layout.tsx import Script from 'next/script'\n \nexport default function DashboardLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <>\n      <section>{children}</section>\n      <Script src=\"https://example.com/script.js\" />\n    </>\n  )\n}The third-party script is fetched when the folder route (e.g. dashboard/page.js) or any nested route (e.g. dashboard/settings/page.js) is accessed by the user. Next.js will ensure the script will only load once, even if a user navigates between multiple routes in the same layout.\nApplication Scripts", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/scripts"}
{"id": "995394ed8592-1", "text": "Application Scripts\nTo load a third-party script for all routes, import next/script and include the script directly in your root layout:app/layout.tsx import Script from 'next/script'\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n      <Script src=\"https://example.com/script.js\" />\n    </html>\n  )\n}\nThis script will load and execute when any route in your application is accessed. Next.js will ensure the script will only load once, even if a user navigates between multiple pages.\nRecommendation: We recommend only including third-party scripts in specific pages or layouts in order to minimize any unnecessary impact to performance.\nStrategy", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/scripts"}
{"id": "995394ed8592-2", "text": "Strategy\nAlthough the default behavior of next/script allows you load third-party scripts in any page or layout, you can fine-tune its loading behavior by using the strategy property:\nbeforeInteractive: Load the script before any Next.js code and before any page hydration occurs.\nafterInteractive: (default) Load the script early but after some hydration on the page occurs.\nlazyOnload: Load the script later during browser idle time.\nworker: (experimental) Load the script in a web worker.\nRefer to the next/script API reference documentation to learn more about each strategy and their use cases.\nOffloading Scripts To A Web Worker (Experimental)\nWarning: The worker strategy is not yet stable and does not yet work with the app directory. Use with caution.\nScripts that use the worker strategy are offloaded and executed in a web worker with Partytown. This can improve the performance of your site by dedicating the main thread to the rest of your application code.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/scripts"}
{"id": "995394ed8592-3", "text": "This strategy is still experimental and can only be used if the nextScriptWorkers flag is enabled in next.config.js:\nnext.config.js module.exports = {\n  experimental: {\n    nextScriptWorkers: true,\n  },\n}\nThen, run next (normally npm run dev or yarn dev) and Next.js will guide you through the installation of the required packages to finish the setup:\nTerminal npm run dev\nYou'll see instructions like these: Please install Partytown by running npm install @builder.io/partytown\nOnce setup is complete, defining strategy=\"worker\" will automatically instantiate Partytown in your application and offload the script to a web worker.\npages/home.tsx import Script from 'next/script'\n \nexport default function Home() {\n  return (\n    <>\n      <Script src=\"https://example.com/script.js\" strategy=\"worker\" />\n    </>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/scripts"}
{"id": "995394ed8592-4", "text": "</>\n  )\n}\nThere are a number of trade-offs that need to be considered when loading a third-party script in a web worker. Please see Partytown's tradeoffs documentation for more information.\nInline Scripts\nInline scripts, or scripts not loaded from an external file, are also supported by the Script component. They can be written by placing the JavaScript within curly braces:\n <Script id=\"show-banner\">\n  {`document.getElementById('banner').classList.remove('hidden')`}\n</Script>\nOr by using the dangerouslySetInnerHTML property:\n <Script\n  id=\"show-banner\"\n  dangerouslySetInnerHTML={{\n    __html: `document.getElementById('banner').classList.remove('hidden')`,\n  }}\n/>\nWarning: An id property must be assigned for inline scripts in order for Next.js to track and optimize the script.\nExecuting Additional Code", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/scripts"}
{"id": "995394ed8592-5", "text": "Executing Additional Code\nEvent handlers can be used with the Script component to execute additional code after a certain event occurs:\nonLoad: Execute code after the script has finished loading.\nonReady: Execute code after the script has finished loading and every time the component is mounted.\nonError: Execute code if the script fails to load.\nThese handlers will only work when next/script is imported and used inside of a Client Component where \"use client\" is defined as the first line of code:app/page.tsx 'use client'\n \nimport Script from 'next/script'\n \nexport default function Page() {\n  return (\n    <>\n      <Script\n        src=\"https://example.com/script.js\"\n        onLoad={() => {\n          console.log('Script has loaded')\n        }}\n      />\n    </>\n  )\n}Refer to the next/script API reference to learn more about each event handler and view examples.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/scripts"}
{"id": "995394ed8592-6", "text": "}Refer to the next/script API reference to learn more about each event handler and view examples.\nAdditional Attributes\nThere are many DOM attributes that can be assigned to a <script> element that are not used by the Script component, like nonce or custom data attributes. Including any additional attributes will automatically forward it to the final, optimized <script> element that is included in the HTML.\napp/page.tsx import Script from 'next/script'\n \nexport default function Page() {\n  return (\n    <>\n      <Script\n        src=\"https://example.com/script.js\"\n        id=\"example-script\"\n        nonce=\"XUENAJFW\"\n        data-test=\"script\"\n      />\n    </>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/scripts"}
{"id": "0819febb67d8-0", "text": "MetadataNext.js has a Metadata API that can be used to define your application metadata (e.g. meta and link tags inside your HTML head element) for improved SEO and web shareability.\nThere are two ways you can add metadata to your application:\nConfig-based Metadata: Export a static metadata object or a dynamic generateMetadata function in a layout.js or page.js file.\nFile-based Metadata: Add static or dynamically generated special files to route segments.\nWith both these options, Next.js will automatically generate the relevant <head> elements for your pages. You can also create dynamic OG images using the ImageResponse constructor.\nStatic Metadata\nTo define static metadata, export a Metadata object from a layout.js or static page.js file.\nlayout.tsx / page.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: '...',\n  description: '...',\n}\n \nexport default function Page() {}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-1", "text": "description: '...',\n}\n \nexport default function Page() {}\nFor all the available options, see the API Reference.\nDynamic Metadata\nYou can use generateMetadata function to fetch metadata that requires dynamic values.\napp/products/[id]/page.tsx import { Metadata, ResolvingMetadata } from 'next'\n \ntype Props = {\n  params: { id: string }\n  searchParams: { [key: string]: string | string[] | undefined }\n}\n \nexport async function generateMetadata(\n  { params, searchParams }: Props,\n  parent?: ResolvingMetadata\n): Promise<Metadata> {\n  // read route params\n  const id = params.id\n \n  // fetch data\n  const product = await fetch(`https://.../${id}`).then((res) => res.json())\n \n  // optionally access and extend (rather than replace) parent metadata", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-2", "text": "// optionally access and extend (rather than replace) parent metadata\n  const previousImages = (await parent).openGraph?.images || []\n \n  return {\n    title: product.title,\n    openGraph: {\n      images: ['/some-specific-page-image.jpg', ...previousImages],\n    },\n  }\n}\n \nexport default function Page({ params, searchParams }: Props) {}\nFor all the available params, see the API Reference.\nGood to know:\nBoth static and dynamic metadata through generateMetadata are only supported in Server Components.\nWhen rendering a route, Next.js will automatically deduplicate fetch requests for the same data across generateMetadata, generateStaticParams, Layouts, Pages, and Server Components. React cache can be used if fetch is unavailable.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-3", "text": "Next.js will wait for data fetching inside generateMetadata to complete before streaming UI to the client. This guarantees the first part of a streamed response includes <head> tags.\nFile-based metadata\nThese special files are available for metadata:\nfavicon.ico, apple-icon.jpg, and icon.jpg\nopengraph-image.jpg and twitter-image.jpg\nrobots.txt\nsitemap.xml\nYou can use these for static metadata, or you can programmatically generate these files with code.\nFor implementation and examples, see the Metadata Files API Reference and Dynamic Image Generation.\nBehavior\nFile-based metadata has the higher priority and will override any config-based metadata.\nDefault Fields\nThere are two default meta tags that are always added even if a route doesn't define metadata:\nThe meta charset tag sets the character encoding for the website.\nThe meta viewport tag sets the viewport width and scale for the website to adjust for different devices.\n <meta charset=\"utf-8\" />", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-4", "text": "<meta charset=\"utf-8\" />\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\nGood to know: You can overwrite the default viewport meta tag.\nOrdering\nMetadata is evaluated in order, starting from the root segment down to the segment closest to the final page.js segment. For example:\napp/layout.tsx (Root Layout)\napp/blog/layout.tsx (Nested Blog Layout)\napp/blog/[slug]/page.tsx (Blog Page)\nMerging\nFollowing the evaluation order, Metadata objects exported from multiple segments in the same route are shallowly merged together to form the final metadata output of a route. Duplicate keys are replaced based on their ordering.\nThis means metadata with nested fields such as openGraph and robots that are defined in an earlier segment are overwritten by the last segment to define them.\nOverwriting fields\napp/layout.js export const metadata = {\n  title: 'Acme',", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-5", "text": "app/layout.js export const metadata = {\n  title: 'Acme',\n  openGraph: {\n    title: 'Acme',\n    description: 'Acme is a...',\n  },\n}\napp/blog/page.js export const metadata = {\n  title: 'Blog',\n  openGraph: {\n    title: 'Blog',\n  },\n}\n \n// Output:\n// <title>Blog</title>\n// <meta property=\"og:title\" content=\"Blog\" />\nIn the example above:\ntitle from app/layout.js is replaced by title in app/blog/page.js.\nAll openGraph fields from app/layout.js are replaced in app/blog/page.js because app/blog/page.js sets openGraph metadata. Note the absence of openGraph.description.\nIf you'd like to share some nested fields between segments while overwriting others, you can pull them out into a separate variable:", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-6", "text": "app/shared-metadata.js export const openGraphImage = { images: ['http://...'] }\napp/page.js import { openGraphImage } from './shared-metadata'\n \nexport const metadata = {\n  openGraph: {\n    ...openGraphImage,\n    title: 'Home',\n  },\n}\napp/about/page.js import { openGraphImage } from '../shared-metadata'\n \nexport const metadata = {\n  openGraph: {\n    ...openGraphImage,\n    title: 'About',\n  },\n}\nIn the example above, the OG image is shared between app/layout.js and app/about/page.js while the titles are different.\nInheriting fields\napp/layout.js export const metadata = {\n  title: 'Acme',\n  openGraph: {\n    title: 'Acme',\n    description: 'Acme is a...',\n  },\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-7", "text": "description: 'Acme is a...',\n  },\n}\napp/about/page.js export const metadata = {\n  title: 'About',\n}\n \n// Output:\n// <title>About</title>\n// <meta property=\"og:title\" content=\"Acme\" />\n// <meta property=\"og:description\" content=\"Acme is a...\" />\nNotes\ntitle from app/layout.js is replaced by title in app/about/page.js.\nAll openGraph fields from app/layout.js are inherited in app/about/page.js because app/about/page.js doesn't set openGraph metadata.\nDynamic Image Generation\nThe ImageResponse constructor allows you to generate dynamic images using JSX and CSS. This is useful for creating social media images such as Open Graph images, Twitter cards, and more.\nImageResponse uses the Edge Runtime, and Next.js automatically adds the correct headers to cached images at the edge, helping improve performance and reducing recomputation.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-8", "text": "To use it, you can import ImageResponse from next/server:\napp/about/route.js import { ImageResponse } from 'next/server'\n \nexport const runtime = 'edge'\n \nexport async function GET() {\n  return new ImageResponse(\n    (\n      <div\n        style={{\n          fontSize: 128,\n          background: 'white',\n          width: '100%',\n          height: '100%',\n          display: 'flex',\n          textAlign: 'center',\n          alignItems: 'center',\n          justifyContent: 'center',\n        }}\n      >\n        Hello world!\n      </div>\n    ),\n    {\n      width: 1200,\n      height: 600,\n    }\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-9", "text": "height: 600,\n    }\n  )\n}\nImageResponse integrates well with other Next.js APIs, including Route Handlers and file-based Metadata. For example, you can use ImageResponse in a opengraph-image.tsx file to generate Open Graph images at build time or dynamically at request time.\nImageResponse supports common CSS properties including flexbox and absolute positioning, custom fonts, text wrapping, centering, and nested images. See the full list of supported CSS properties.\nGood to know:\nExamples are available in the Vercel OG Playground.\nImageResponse uses @vercel/og, Satori, and Resvg to convert HTML and CSS into PNG.\nOnly the Edge Runtime is supported. The default Node.js runtime will not work.\nOnly flexbox and a subset of CSS properties are supported. Advanced layouts (e.g. display: grid) will not work.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-10", "text": "Maximum bundle size of 500KB. The bundle size includes your JSX, CSS, fonts, images, and any other assets. If you exceed the limit, consider reducing the size of any assets or fetching at runtime.\nOnly ttf, otf, and woff font formats are supported. To maximize the font parsing speed, ttf or otf are preferred over woff.\nJSON-LD\nJSON-LD is a format for structured data that can be used by search engines to understand your content. For example, you can use it to describe a person, an event, an organization, a movie, a book, a recipe, and many other types of entities.\nOur current recommendation for JSON-LD is to render structured data as a <script> tag in your layout.js or page.js components. For example:\napp/products/[id]/page.tsx export default async function Page({ params }) {\n  const product = await getProduct(params.id)", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-11", "text": "const product = await getProduct(params.id)\n \n  const jsonLd = {\n    '@context': 'https://schema.org',\n    '@type': 'Product',\n    name: product.name,\n    image: product.image,\n    description: product.description,\n  }\n \n  return (\n    <section>\n      {/* Add JSON-LD to your page */}\n      <script\n        type=\"application/ld+json\"\n        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}\n      />\n      {/* ... */}\n    </section>\n  )\n}\nYou can validate and test your structured data with the Rich Results Test for Google or the generic Schema Markup Validator.\nYou can type your JSON-LD with TypeScript using community packages like schema-dts:\n import { Product, WithContext } from 'schema-dts'", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "0819febb67d8-12", "text": "import { Product, WithContext } from 'schema-dts'\n \nconst jsonLd: WithContext<Product> = {\n  '@context': 'https://schema.org',\n  '@type': 'Product',\n  name: 'Next.js Sticker',\n  image: 'https://nextjs.org/imgs/sticker.png',\n  description: 'Dynamic at the speed of static.',\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/metadata"}
{"id": "415cdb6e1cf0-0", "text": "Static Assets\nNext.js can serve static files, like images, under a folder called public in the root directory. Files inside public can then be referenced by your code starting from the base URL (/).\nFor example, if you add me.png inside public, the following code will access the image:\nAvatar.js import Image from 'next/image'\n \nexport function Avatar() {\n  return <Image src=\"/me.png\" alt=\"me\" width=\"64\" height=\"64\" />\n}\nFor static metadata files, such as robots.txt, favicon.ico, etc, you should use special metadata files inside the app folder.\nGood to know:\nThe directory must be named public. The name cannot be changed and it's the only directory used to serve static assets.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/static-assets"}
{"id": "415cdb6e1cf0-1", "text": "Only assets that are in the public directory at build time will be served by Next.js. Files added at runtime won't be available. We recommend using a third-party service like AWS S3 for persistent file storage.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/static-assets"}
{"id": "444d1c061cc6-0", "text": "Lazy Loading\nLazy loading in Next.js helps improve the initial loading performance of an application by decreasing the amount of JavaScript needed to render a route.\nIt allows you to defer loading of Client Components and imported libraries, and only include them in the client bundle when they're needed. For example, you might want to defer loading a modal until a user clicks to open it.\nThere are two ways you can implement lazy loading in Next.js:\nUsing Dynamic Imports with next/dynamic\nUsing React.lazy() with Suspense\nBy default, Server Components are automatically code split, and you can use streaming to progressively send pieces of UI from the server to the client. Lazy loading applies to Client Components.\nnext/dynamic\nnext/dynamic is a composite of React.lazy() and Suspense. It behaves the same way in the app and pages directories to allow for incremental migration.\nExamples\nImporting Client Components\napp/page.js 'use client'", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading"}
{"id": "444d1c061cc6-1", "text": "Examples\nImporting Client Components\napp/page.js 'use client'\n \nimport { useState } from 'react'\nimport dynamic from 'next/dynamic'\n \n// Client Components:\nconst ComponentA = dynamic(() => import('../components/A'))\nconst ComponentB = dynamic(() => import('../components/B'))\nconst ComponentC = dynamic(() => import('../components/C'), { ssr: false })\n \nexport default function ClientComponentExample() {\n  const [showMore, setShowMore] = useState(false)\n \n  return (\n    <div>\n      {/* Load immediately, but in a separate client bundle */}\n      <ComponentA />\n \n      {/* Load on demand, only when/if the condition is met */}\n      {showMore && <ComponentB />}\n      <button onClick={() => setShowMore(!showMore)}>Toggle</button>", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading"}
{"id": "444d1c061cc6-2", "text": "<button onClick={() => setShowMore(!showMore)}>Toggle</button>\n \n      {/* Load only on the client side */}\n      <ComponentC />\n    </div>\n  )\n}Skipping SSR\nWhen using React.lazy() and Suspense, Client Components will be pre-rendered (SSR) by default.If you want to disable pre-rendering for a Client Component, you can use the ssr option set to false: const ComponentC = dynamic(() => import('../components/C'), { ssr: false })Importing Server Components\nIf you dynamically import a Server Component, only the Client Components that are children of the Server Component will be lazy-loaded - not the Server Component itself.app/page.js import dynamic from 'next/dynamic'\n \n// Server Component:\nconst ServerComponent = dynamic(() => import('../components/ServerComponent'))\n \nexport default function ServerComponentExample() {\n  return (\n    <div>", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading"}
{"id": "444d1c061cc6-3", "text": "export default function ServerComponentExample() {\n  return (\n    <div>\n      <ServerComponent />\n    </div>\n  )\n}Loading External Libraries\nExternal libraries can be loaded on demand using the import() function. This example uses the external library fuse.js for fuzzy search. The module is only loaded on the client after the user types in the search input.app/page.js 'use client'\n \nimport { useState } from 'react'\n \nconst names = ['Tim', 'Joe', 'Bel', 'Lee']\n \nexport default function Page() {\n  const [results, setResults] = useState()\n \n  return (\n    <div>\n      <input\n        type=\"text\"\n        placeholder=\"Search\"\n        onChange={async (e) => {\n          const { value } = e.currentTarget\n          // Dynamically load fuse.js", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading"}
{"id": "444d1c061cc6-4", "text": "const { value } = e.currentTarget\n          // Dynamically load fuse.js\n          const Fuse = (await import('fuse.js')).default\n          const fuse = new Fuse(names)\n \n          setResults(fuse.search(value))\n        }}\n      />\n      <pre>Results: {JSON.stringify(results, null, 2)}</pre>\n    </div>\n  )\n}Adding a custom loading component\napp/page.js import dynamic from 'next/dynamic'\n \nconst WithCustomLoading = dynamic(\n  () => import('../components/WithCustomLoading'),\n  {\n    loading: () => <p>Loading...</p>,\n  }\n)\n \nexport default function Page() {\n  return (\n    <div>\n      {/* The loading component will be rendered while  <WithCustomLoading/> is loading */}\n      <WithCustomLoading />\n    </div>\n  )", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading"}
{"id": "444d1c061cc6-5", "text": "<WithCustomLoading />\n    </div>\n  )\n}Importing Named Exports\nTo dynamically import a named export, you can return it from the Promise returned by import() function:components/hello.js 'use client'\n \nexport function Hello() {\n  return <p>Hello!</p>\n}app/page.js import dynamic from 'next/dynamic'\n \nconst ClientComponent = dynamic(() =>\n  import('../components/hello').then((mod) => mod.Hello)\n)", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading"}
{"id": "bc476e93bd3f-0", "text": "Analytics\nNext.js Speed Insights allows you to analyze and measure the performance of\npages using different metrics.\nYou can start collecting your Real Experience Score with zero-configuration on Vercel deployments.\nThe rest of this documentation describes the built-in relayer Next.js Speed Insights uses.\nWeb Vitals\nWeb Vitals are a set of useful metrics that aim to capture the user\nexperience of a web page. The following web vitals are all included:\nTime to First Byte (TTFB)\nFirst Contentful Paint (FCP)\nLargest Contentful Paint (LCP)\nFirst Input Delay (FID)\nCumulative Layout Shift (CLS)\nInteraction to Next Paint (INP) (experimental)", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/analytics"}
{"id": "b9c862b437d7-0", "text": "OpenTelemetry\nGood to know: This feature is experimental, you need to explicitly opt-in by providing experimental.instrumentationHook = true; in your next.config.js.\nObservability is crucial for understanding and optimizing the behavior and performance of your Next.js app.\nAs applications become more complex, it becomes increasingly difficult to identify and diagnose issues that may arise. By leveraging observability tools, such as logging and metrics, developers can gain insights into their application's behavior and identify areas for optimization. With observability, developers can proactively address issues before they become major problems and provide a better user experience. Therefore, it is highly recommended to use observability in your Next.js applications to improve performance, optimize resources, and enhance user experience.\nWe recommend using OpenTelemetry for instrumenting your apps.\nIt's a platform-agnostic way to instrument apps that allows you to change your observability provider without changing your code.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-1", "text": "Read Official OpenTelemetry docs for more information about OpenTelemetry and how it works.\nThis documentation uses terms like Span, Trace or Exporter throughout this doc, all of which can be found in the OpenTelemetry Observability Primer.\nNext.js supports OpenTelemetry instrumentation out of the box, which means that we already instrumented Next.js itself.\nWhen you enable OpenTelemetry we will automatically wrap all your code like getStaticProps in spans with helpful attributes.\nGood to know: We currently support OpenTelemetry bindings only in serverless functions.\nWe don't provide any for edge or client side code.\nGetting Started\nOpenTelemetry is extensible but setting it up properly can be quite verbose.\nThat's why we prepared a package @vercel/otel that helps you get started quickly.\nIt's not extensible and you should configure OpenTelemetry manually if you need to customize your setup.\nUsing @vercel/otel", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-2", "text": "Using @vercel/otel\nTo get started, you must install @vercel/otel:\nTerminal npm install @vercel/otel\nNext, create a custom instrumentation.ts (or .js) file in the root directory of the project (or inside src folder if using one):\nyour-project/instrumentation.ts import { registerOTel } from '@vercel/otel'\n \nexport function register() {\n  registerOTel('next-app')\n}\nGood to know\nThe instrumentation file should be in the root of your project and not inside the app or pages directory. If you're using the src folder, then place the file inside src alongside pages and app.\nIf you use the pageExtensions config option to add a suffix, you will also need to update the instrumentation filename to match.\nWe have created a basic with-opentelemetry example that you can use.\nManual OpenTelemetry configuration", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-3", "text": "Manual OpenTelemetry configuration\nIf our wrapper @vercel/otel doesn't suit your needs, you can configure OpenTelemetry manually.\nFirstly you need to install OpenTelemetry packages:\nTerminal npm install @opentelemetry/sdk-node @opentelemetry/resources @opentelemetry/semantic-conventions @opentelemetry/sdk-trace-node @opentelemetry/exporter-trace-otlp-http\nNow you can initialize NodeSDK in your instrumentation.ts.\nOpenTelemetry APIs are not compatible with edge runtime, so you need to make sure that you are importing them only when process.env.NEXT_RUNTIME === 'nodejs'. We recommend creating a new file instrumentation.node.ts which you conditionally import only when using node:\ninstrumentation.ts export async function register() {\n  if (process.env.NEXT_RUNTIME === 'nodejs') {\n    await import('./instrumentation.node.ts')\n  }\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-4", "text": "await import('./instrumentation.node.ts')\n  }\n}\ninstrumentation.node.ts import { NodeSDK } from '@opentelemetry/sdk-node'\nimport { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'\nimport { Resource } from '@opentelemetry/resources'\nimport { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'\nimport { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node'\n \nconst sdk = new NodeSDK({\n  resource: new Resource({\n    [SemanticResourceAttributes.SERVICE_NAME]: 'next-app',\n  }),\n  spanProcessor: new SimpleSpanProcessor(new OTLPTraceExporter()),\n})\nsdk.start()\nDoing this is equivalent to using @vercel/otel, but it's possible to modify and extend.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-5", "text": "For example, you could use @opentelemetry/exporter-trace-otlp-grpc instead of @opentelemetry/exporter-trace-otlp-http or you can specify more resource attributes.\nTesting your instrumentation\nYou need an OpenTelemetry collector with a compatible backend to test OpenTelemetry traces locally.\nWe recommend using our OpenTelemetry dev environment.\nIf everything works well you should be able to see the root server span labeled as GET /requested/pathname.\nAll other spans from that particular trace will be nested under it.\nNext.js traces more spans than are emitted by default.\nTo see more spans, you must set NEXT_OTEL_VERBOSE=1.\nDeployment\nUsing OpenTelemetry Collector\nWhen you are deploying with OpenTelemetry Collector, you can use @vercel/otel.\nIt will work both on Vercel and when self-hosted.\nDeploying on Vercel", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-6", "text": "Deploying on Vercel\nWe made sure that OpenTelemetry works out of the box on Vercel.\nFollow Vercel documentation to connect your project to an observability provider.\nSelf-hosting\nDeploying to other platforms is also straightforward. You will need to spin up your own OpenTelemetry Collector to receive and process the telemetry data from your Next.js app.\nTo do this, follow the OpenTelemetry Collector Getting Started guide, which will walk you through setting up the collector and configuring it to receive data from your Next.js app.\nOnce you have your collector up and running, you can deploy your Next.js app to your chosen platform following their respective deployment guides.\nCustom Exporters\nWe recommend using OpenTelemetry Collector.\nIf that is not possible on your platform, you can use a custom OpenTelemetry exporter with manual OpenTelemetry configuration\nCustom Spans\nYou can add a custom span with OpenTelemetry APIs.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-7", "text": "Custom Spans\nYou can add a custom span with OpenTelemetry APIs.\nTerminal npm install @opentelemetry/api\nThe following example demonstrates a function that fetches GitHub stars and adds a custom fetchGithubStars span to track the fetch request's result:\n import { trace } from '@opentelemetry/api'\n \nexport async function fetchGithubStars() {\n  return await trace\n    .getTracer('nextjs-example')\n    .startActiveSpan('fetchGithubStars', async (span) => {\n      try {\n        return await getValue()\n      } finally {\n        span.end()\n      }\n    })\n}\nThe register function will execute before your code runs in a new environment.\nYou can start creating new spans, and they should be correctly added to the exported trace.\nDefault Spans in Next.js\nNext.js automatically instruments several spans for you to provide useful insights into your application's performance.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-8", "text": "Next.js automatically instruments several spans for you to provide useful insights into your application's performance.\nAttributes on spans follow OpenTelemetry semantic conventions. We also add some custom attributes under the next namespace:\nnext.span_name - duplicates span name\nnext.span_type - each span type has a unique identifier\nnext.route - The route pattern of the request (e.g., /[param]/user).\nnext.page\nThis is an internal value used by an app router.\nYou can think about it as a route to a special file (like page.ts, layout.ts, loading.ts and others)\nIt can be used as a unique identifier only when paired with next.route because /layout can be used to identify both /(groupA)/layout.ts and /(groupB)/layout.ts\n[http.method] [next.route]\nnext.span_type: BaseServer.handleRequest", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-9", "text": "[http.method] [next.route]\nnext.span_type: BaseServer.handleRequest\nThis span represents the root span for each incoming request to your Next.js application. It tracks the HTTP method, route, target, and status code of the request.\nAttributes:\nCommon HTTP attributes\nhttp.method\nhttp.status_code\nServer HTTP attributes\nhttp.route\nhttp.target\nnext.span_name\nnext.span_type\nnext.route\nrender route (app) [next.route]\nnext.span_type: AppRender.getBodyResult.\nThis span represents the process of rendering a route in the app router.\nAttributes:\nnext.span_name\nnext.span_type\nnext.route\nfetch [http.method] [http.url]\nnext.span_type: AppRender.fetch\nThis span represents the fetch request executed in your code.\nAttributes:\nCommon HTTP attributes\nhttp.method\nClient HTTP attributes\nhttp.url\nnet.peer.name\nnet.peer.port (only if specified)\nnext.span_name", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-10", "text": "http.url\nnet.peer.name\nnet.peer.port (only if specified)\nnext.span_name\nnext.span_type\nexecuting api route (app) [next.route]\nnext.span_type: AppRouteRouteHandlers.runHandler.\nThis span represents the execution of an API route handler in the app router.\nAttributes:\nnext.span_name\nnext.span_type\nnext.route\ngetServerSideProps [next.route]\nnext.span_type: Render.getServerSideProps.\nThis span represents the execution of getServerSideProps for a specific route.\nAttributes:\nnext.span_name\nnext.span_type\nnext.route\ngetStaticProps [next.route]\nnext.span_type: Render.getStaticProps.\nThis span represents the execution of getStaticProps for a specific route.\nAttributes:\nnext.span_name\nnext.span_type\nnext.route\nrender route (pages) [next.route]\nnext.span_type: Render.renderDocument.", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "b9c862b437d7-11", "text": "render route (pages) [next.route]\nnext.span_type: Render.renderDocument.\nThis span represents the process of rendering the document for a specific route.\nAttributes:\nnext.span_name\nnext.span_type\nnext.route\ngenerateMetadata [next.page]\nnext.span_type: ResolveMetadata.generateMetadata.\nThis span represents the process of generating metadata for a specific page (a single route can have multiple of these spans).\nAttributes:\nnext.span_name\nnext.span_type\nnext.page", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/open-telemetry"}
{"id": "4204567cba57-0", "text": "Instrumentation\nIf you export a function named register from a instrumentation.ts (or .js) file in the root directory of your project (or inside the src folder if using one), we will call that function whenever a new Next.js server instance is bootstrapped.\nGood to know\nThis feature is experimental. To use it, you must explicitly opt in by defining experimental.instrumentationHook = true; in your next.config.js.\nThe instrumentation file should be in the root of your project and not inside the app or pages directory. If you're using the src folder, then place the file inside src alongside pages and app.\nIf you use the pageExtensions config option to add a suffix, you will also need to update the instrumentation filename to match.\nWe have created a basic with-opentelemetry example that you can use.\nWhen your register function is deployed, it will be called on each cold boot (but exactly once in each environment).", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation"}
{"id": "4204567cba57-1", "text": "Sometimes, it may be useful to import a file in your code because of the side effects it will cause. For example, you might import a file that defines a set of global variables, but never explicitly use the imported file in your code. You would still have access to the global variables the package has declared.\nYou can import files with side effects in instrumentation.ts, which you might want to use in your register function as demonstrated in the following example:\nyour-project/instrumentation.ts import { init } from 'package-init'\n \nexport function register() {\n  init()\n}\nHowever, we recommend importing files with side effects using import from within your register function instead. The following example demonstrates a basic usage of import in a register function:\nyour-project/instrumentation.ts export async function register() {\n  await import('package-with-side-effect')\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation"}
{"id": "4204567cba57-2", "text": "await import('package-with-side-effect')\n}\nBy doing this, you can colocate all of your side effects in one place in your code, and avoid any unintended consequences from importing files.\nWe call register in all environments, so it's necessary to conditionally import any code that doesn't support both edge and nodejs. You can use the environment variable NEXT_RUNTIME to get the current environment. Importing an environment-specific code would look like this:\nyour-project/instrumentation.ts export async function register() {\n  if (process.env.NEXT_RUNTIME === 'nodejs') {\n    await import('./instrumentation-node')\n  }\n \n  if (process.env.NEXT_RUNTIME === 'edge') {\n    await import('./instrumentation-edge')\n  }\n}", "source": "https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation"}
{"id": "ec80654191bd-0", "text": "TypeScript\nNext.js provides a TypeScript-first development experience for building your React application.\nIt comes with built-in TypeScript support for automatically installing the necessary packages and configuring the proper settings.\nAs well as a TypeScript Plugin for your editor.\n\ud83c\udfa5 Watch: Learn about the built-in TypeScript plugin \u2192 YouTube (3 minutes)\nNew Projects\ncreate-next-app now ships with TypeScript by default.\nTerminal npx create-next-app@latest\nExisting Projects\nAdd TypeScript to your project by renaming a file to .ts / .tsx. Run next dev and next build to automatically install the necessary dependencies and add a tsconfig.json file with the recommended config options.\nIf you already had a jsconfig.json file, copy the paths compiler option from the old jsconfig.json into the new tsconfig.json file, and delete the old jsconfig.json file.\nTypeScript Plugin", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-1", "text": "TypeScript Plugin\nNext.js includes a custom TypeScript plugin and type checker, which VSCode and other code editors can use for advanced type-checking and auto-completion.You can enable the plugin in VS Code by:\nOpening the command palette (Ctrl/\u2318 + Shift + P)\nSearching for \"TypeScript: Select TypeScript Version\"\nSelecting \"Use Workspace Version\"\nNow, when editing files, the custom plugin will be enabled. When running next build, the custom type checker will be used.Plugin Features\nThe TypeScript plugin can help with:\nWarning if the invalid values for segment config options are passed.\nShowing available options and in-context documentation.\nEnsuring the use client directive is used correctly.\nEnsuring client hooks (like useState) are only used in Client Components.\nGood to know: More features will be added in the future.\nMinimum TypeScript Version", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-2", "text": "Good to know: More features will be added in the future.\nMinimum TypeScript Version\nIt is highly recommended to be on at least v4.5.2 of TypeScript to get syntax features such as type modifiers on import names and performance improvements.\nStatically Typed Links\nNext.js can statically type links to prevent typos and other errors when using next/link, improving type safety when navigating between pages.To opt-into this feature, experimental.typedRoutes need to be enabled and the project needs to be using TypeScript.next.config.js /** @type {import('next').NextConfig} */\nconst nextConfig = {\n  experimental: {\n    typedRoutes: true,\n  },\n}", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-3", "text": "experimental: {\n    typedRoutes: true,\n  },\n}\n \nmodule.exports = nextConfigNext.js will generate a link definition in .next/types that contains information about all existing routes in your application, which TypeScript can then use to provide feedback in your editor about invalid links.Currently, experimental support includes any string literal, including dynamic segments. For non-literal strings, you currently need to manually cast the href with as Route: import type { Route } from 'next';\nimport Link from 'next/link'\n \n// No TypeScript errors if href is a valid route\n<Link href=\"/about\" />\n<Link href=\"/blog/nextjs\" />\n<Link href={`/blog/${slug}`} />\n<Link href={('/blog' + slug) as Route} />\n \n// TypeScript errors if href is not a valid route", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-4", "text": "// TypeScript errors if href is not a valid route\n<Link href=\"/aboot\" />To accept href in a custom component wrapping next/link, use a generic: import type { Route } from 'next'\nimport Link from 'next/link'\n \nfunction Card<T extends string>({ href }: { href: Route<T> | URL }) {\n  return (\n    <Link href={href}>\n      <div>My Card</div>\n    </Link>\n  )\n}\nHow does it work?\nWhen running next dev or next build, Next.js generates a hidden .d.ts file inside .next that contains information about all existing routes in your application (all valid routes as the href type of Link). This .d.ts file is included in tsconfig.json and the TypeScript compiler will check that .d.ts and provide feedback in your editor about invalid links.\nEnd-to-End Type Safety", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-5", "text": "End-to-End Type Safety\nNext.js 13 has enhanced type safety. This includes:\nNo serialization of data between fetching function and page: You can fetch directly in components, layouts, and pages on the server. This data does not need to be serialized (converted to a string) to be passed to the client side for consumption in React. Instead, since app uses Server Components by default, we can use values like Date, Map, Set, and more without any extra steps. Previously, you needed to manually type the boundary between server and client with Next.js-specific types.\nStreamlined data flow between components: With the removal of _app in favor of root layouts, it is now easier to visualize the data flow between components and pages. Previously, data flowing between individual pages and _app were difficult to type and could introduce confusing bugs. With colocated data fetching in Next.js 13, this is no longer an issue.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-6", "text": "Data Fetching in Next.js now provides as close to end-to-end type safety as possible without being prescriptive about your database or content provider selection.We're able to type the response data as you would expect with normal TypeScript. For example:app/page.tsx async function getData() {\n  const res = await fetch('https://api.example.com/...')\n  // The return value is *not* serialized\n  // You can return Date, Map, Set, etc.\n  return res.json()\n}\n \nexport default async function Page() {\n  const name = await getData()\n \n  return '...'\n}For complete end-to-end type safety, this also requires your database or content provider to support TypeScript. This could be through using an ORM or type-safe query builder.Async Server Component TypeScript Error", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-7", "text": "To use an async Server Component with TypeScript, ensure you are using TypeScript 5.1.3 or higher and @types/react 18.2.8 or higher.If you are using an older version of TypeScript, you may see a 'Promise<Element>' is not a valid JSX element type error. Updating to the latest version of TypeScript and @types/react should resolve this issue.Passing Data Between Server & Client Components\nWhen passing data between a Server and Client Component through props, the data is still serialized (converted to a string) for use in the browser. However, it does not need a special type. It\u2019s typed the same as passing any other props between components.Further, there is less code to be serialized, as un-rendered data does not cross between the server and client (it remains on the server). This is only now possible through support for Server Components.\nPath aliases and baseUrl", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-8", "text": "Path aliases and baseUrl\nNext.js automatically supports the tsconfig.json \"paths\" and \"baseUrl\" options.\nYou can learn more about this feature on the Module Path aliases documentation.\nType checking next.config.js\nThe next.config.js file must be a JavaScript file as it does not get parsed by Babel or TypeScript, however you can add some type checking in your IDE using JSDoc as below:\n // @ts-check\n \n/**\n * @type {import('next').NextConfig}\n **/\nconst nextConfig = {\n  /* config options here */\n}\n \nmodule.exports = nextConfig\nIncremental type checking\nSince v10.2.1 Next.js supports incremental type checking when enabled in your tsconfig.json, this can help speed up type checking in larger applications.\nIgnoring TypeScript Errors\nNext.js fails your production build (next build) when TypeScript errors are present in your project.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-9", "text": "Next.js fails your production build (next build) when TypeScript errors are present in your project.\nIf you'd like Next.js to dangerously produce production code even when your application has errors, you can disable the built-in type checking step.\nIf disabled, be sure you are running type checks as part of your build or deploy process, otherwise this can be very dangerous.\nOpen next.config.js and enable the ignoreBuildErrors option in the typescript config:\nnext.config.js module.exports = {\n  typescript: {\n    // !! WARN !!\n    // Dangerously allow production builds to successfully complete even if\n    // your project has type errors.\n    // !! WARN !!\n    ignoreBuildErrors: true,\n  },\n}\nVersion Changes", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "ec80654191bd-10", "text": "ignoreBuildErrors: true,\n  },\n}\nVersion Changes\nVersionChangesv13.2.0Statically typed links are available in beta.v12.0.0SWC is now used by default to compile TypeScript and TSX for faster builds.v10.2.1Incremental type checking support added when enabled in your tsconfig.json.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/typescript"}
{"id": "37619058cc26-0", "text": "ESLint\nNext.js provides an integrated ESLint experience out of the box. Add next lint as a script to package.json:\npackage.json {\n  \"scripts\": {\n    \"lint\": \"next lint\"\n  }\n}\nThen run npm run lint or yarn lint:\nTerminal yarn lint\nIf you don't already have ESLint configured in your application, you will be guided through the installation and configuration process.\nTerminal yarn lint\nYou'll see a prompt like this:\n? How would you like to configure ESLint?\n\u276f Strict (recommended)\nBase\nCancel\nOne of the following three options can be selected:\nStrict: Includes Next.js' base ESLint configuration along with a stricter Core Web Vitals rule-set. This is the recommended configuration for developers setting up ESLint for the first time.\n.eslintrc.json {\n  \"extends\": \"next/core-web-vitals\"\n}", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-1", "text": "\"extends\": \"next/core-web-vitals\"\n}\nBase: Includes Next.js' base ESLint configuration.\n.eslintrc.json {\n  \"extends\": \"next\"\n}\nCancel: Does not include any ESLint configuration. Only select this option if you plan on setting up your own custom ESLint configuration.\nIf either of the two configuration options are selected, Next.js will automatically install eslint and eslint-config-next as development dependencies in your application and create an .eslintrc.json file in the root of your project that includes your selected configuration.\nYou can now run next lint every time you want to run ESLint to catch errors. Once ESLint has been set up, it will also automatically run during every build (next build). Errors will fail the build, while warnings will not.\nIf you do not want ESLint to run during next build, refer to the documentation for Ignoring ESLint.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-2", "text": "We recommend using an appropriate integration to view warnings and errors directly in your code editor during development.\nESLint Config\nThe default configuration (eslint-config-next) includes everything you need to have an optimal out-of-the-box linting experience in Next.js. If you do not have ESLint already configured in your application, we recommend using next lint to set up ESLint along with this configuration.\nIf you would like to use eslint-config-next along with other ESLint configurations, refer to the Additional Configurations section to learn how to do so without causing any conflicts.\nRecommended rule-sets from the following ESLint plugins are all used within eslint-config-next:\neslint-plugin-react\neslint-plugin-react-hooks\neslint-plugin-next\nThis will take precedence over the configuration from next.config.js.\nESLint Plugin", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-3", "text": "This will take precedence over the configuration from next.config.js.\nESLint Plugin\nNext.js provides an ESLint plugin, eslint-plugin-next, already bundled within the base configuration that makes it possible to catch common issues and problems in a Next.js application. The full set of rules is as follows:\n Enabled in the recommended configuration", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-4", "text": "RuleDescription@next/next/google-font-displayEnforce font-display behavior with Google Fonts.@next/next/google-font-preconnectEnsure preconnect is used with Google Fonts.@next/next/inline-script-idEnforce id attribute on next/script components with inline content.@next/next/next-script-for-gaPrefer next/script component when using the inline script for Google Analytics.@next/next/no-assign-module-variablePrevent assignment to the module variable.@next/next/no-async-client-componentPrevent client components from being async functions.@next/next/no-before-interactive-script-outside-documentPrevent usage of next/script's beforeInteractive strategy outside of pages/_document.js.@next/next/no-css-tagsPrevent manual stylesheet tags.@next/next/no-document-import-in-pagePrevent importing next/document outside of pages/_document.js.@next/next/no-duplicate-headPrevent duplicate usage of <Head> in pages/_document.js.@next/next/no-head-elementPrevent usage", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-5", "text": "usage of <Head> in pages/_document.js.@next/next/no-head-elementPrevent usage of <head> element.@next/next/no-head-import-in-documentPrevent usage of next/head in pages/_document.js.@next/next/no-html-link-for-pagesPrevent usage of <a> elements to navigate to internal Next.js pages.@next/next/no-img-elementPrevent usage of <img> element due to slower LCP and higher bandwidth.@next/next/no-page-custom-fontPrevent page-only custom fonts.@next/next/no-script-component-in-headPrevent usage of next/script in next/head component.@next/next/no-styled-jsx-in-documentPrevent usage of styled-jsx in pages/_document.js.@next/next/no-sync-scriptsPrevent synchronous scripts.@next/next/no-title-in-document-headPrevent usage of <title> with Head component from next/document.@next/next/no-typosPrevent common typos in Next.js's data fetching", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-6", "text": "common typos in Next.js's data fetching functions@next/next/no-unwanted-polyfillioPrevent duplicate polyfills from Polyfill.io.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-7", "text": "If you already have ESLint configured in your application, we recommend extending from this plugin directly instead of including eslint-config-next unless a few conditions are met. Refer to the Recommended Plugin Ruleset to learn more.\nCustom Settings\nrootDir\nIf you're using eslint-plugin-next in a project where Next.js isn't installed in your root directory (such as a monorepo), you can tell eslint-plugin-next where to find your Next.js application using the settings property in your .eslintrc:\n.eslintrc.json {\n  \"extends\": \"next\",\n  \"settings\": {\n    \"next\": {\n      \"rootDir\": \"packages/my-app/\"\n    }\n  }\n}\nrootDir can be a path (relative or absolute), a glob (i.e. \"packages/*/\"), or an array of paths and/or globs.\nLinting Custom Directories and Files", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-8", "text": "Linting Custom Directories and Files\nBy default, Next.js will run ESLint for all files in the pages/, app/, components/, lib/, and src/ directories. However, you can specify which directories using the dirs option in the eslint config in next.config.js for production builds:\nnext.config.js module.exports = {\n  eslint: {\n    dirs: ['pages', 'utils'], // Only run ESLint on the 'pages' and 'utils' directories during production builds (next build)\n  },\n}\nSimilarly, the --dir and --file flags can be used for next lint to lint specific directories and files:\nTerminal next lint --dir pages --dir utils --file bar.js\nCaching", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-9", "text": "Terminal next lint --dir pages --dir utils --file bar.js\nCaching\nTo improve performance, information of files processed by ESLint are cached by default. This is stored in .next/cache or in your defined build directory. If you include any ESLint rules that depend on more than the contents of a single source file and need to disable the cache, use the --no-cache flag with next lint.\nTerminal next lint --no-cache\nDisabling Rules\nIf you would like to modify or disable any rules provided by the supported plugins (react, react-hooks, next), you can directly change them using the rules property in your .eslintrc:\n.eslintrc.json {\n  \"extends\": \"next\",\n  \"rules\": {\n    \"react/no-unescaped-entities\": \"off\",\n    \"@next/next/no-page-custom-font\": \"off\"\n  }\n}\nCore Web Vitals", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-10", "text": "}\n}\nCore Web Vitals\nThe next/core-web-vitals rule set is enabled when next lint is run for the first time and the strict option is selected.\n.eslintrc.json {\n  \"extends\": \"next/core-web-vitals\"\n}\nnext/core-web-vitals updates eslint-plugin-next to error on a number of rules that are warnings by default if they affect Core Web Vitals.\nThe next/core-web-vitals entry point is automatically included for new applications built with Create Next App.\nUsage With Other Tools\nPrettier\nESLint also contains code formatting rules, which can conflict with your existing Prettier setup. We recommend including eslint-config-prettier in your ESLint config to make ESLint and Prettier work together.\nFirst, install the dependency:\nTerminal npm install --save-dev eslint-config-prettier\n \nyarn add --dev eslint-config-prettier", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-11", "text": "yarn add --dev eslint-config-prettier\nThen, add prettier to your existing ESLint config:\n.eslintrc.json {\n  \"extends\": [\"next\", \"prettier\"]\n}\nlint-staged\nIf you would like to use next lint with lint-staged to run the linter on staged git files, you'll have to add the following to the .lintstagedrc.js file in the root of your project in order to specify usage of the --file flag.\n.lintstagedrc.js const path = require('path')\n \nconst buildEslintCommand = (filenames) =>\n  `next lint --fix --file ${filenames\n    .map((f) => path.relative(process.cwd(), f))\n    .join(' --file ')}`\n \nmodule.exports = {\n  '*.{js,jsx,ts,tsx}': [buildEslintCommand],", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-12", "text": "'*.{js,jsx,ts,tsx}': [buildEslintCommand],\n}\nMigrating Existing Config\nRecommended Plugin Ruleset\nIf you already have ESLint configured in your application and any of the following conditions are true:\nYou have one or more of the following plugins already installed (either separately or through a different config such as airbnb or react-app):\nreact\nreact-hooks\njsx-a11y\nimport\nYou've defined specific parserOptions that are different from how Babel is configured within Next.js (this is not recommended unless you have customized your Babel configuration)\nYou have eslint-plugin-import installed with Node.js and/or TypeScript resolvers defined to handle imports\nThen we recommend either removing these settings if you prefer how these properties have been configured within eslint-config-next or extending directly from the Next.js ESLint plugin instead:\n module.exports = {\n  extends: [\n    //...", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-13", "text": "module.exports = {\n  extends: [\n    //...\n    'plugin:@next/next/recommended',\n  ],\n}\nThe plugin can be installed normally in your project without needing to run next lint:\nTerminal npm install --save-dev @next/eslint-plugin-next\n \nyarn add --dev @next/eslint-plugin-next\nThis eliminates the risk of collisions or errors that can occur due to importing the same plugin or parser across multiple configurations.\nAdditional Configurations\nIf you already use a separate ESLint configuration and want to include eslint-config-next, ensure that it is extended last after other configurations. For example:\n.eslintrc.json {\n  \"extends\": [\"eslint:recommended\", \"next\"]\n}\nThe next configuration already handles setting default values for the parser, plugins and settings properties. There is no need to manually re-declare any of these properties unless you need a different configuration for your use case.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "37619058cc26-14", "text": "If you include any other shareable configurations, you will need to make sure that these properties are not overwritten or modified. Otherwise, we recommend removing any configurations that share behavior with the next configuration or extending directly from the Next.js ESLint plugin as mentioned above.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/eslint"}
{"id": "8404cd2451c8-0", "text": "Environment Variables\nExamples\nEnvironment Variables\nNext.js comes with built-in support for environment variables, which allows you to do the following:\nUse .env.local to load environment variables\nBundle environment variables for the browser by prefixing with NEXT_PUBLIC_\nLoading Environment Variables\nNext.js has built-in support for loading environment variables from .env.local into process.env.\n.env.local DB_HOST=localhost\nDB_USER=myuser\nDB_PASS=mypassword\nThis loads process.env.DB_HOST, process.env.DB_USER, and process.env.DB_PASS into the Node.js environment automatically allowing you to use them in Route Handlers.For example:app/api/route.js export async function GET() {\n  const db = await myDB.connect({\n    host: process.env.DB_HOST,\n    username: process.env.DB_USER,\n    password: process.env.DB_PASS,\n  })\n  // ...\n}\nReferencing Other Variables", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-1", "text": "})\n  // ...\n}\nReferencing Other Variables\nNext.js will automatically expand variables that use $ to reference other variables e.g. $VARIABLE inside of your .env* files. This allows you to reference other secrets. For example:\n.env TWITTER_USER=nextjs\nTWITTER_URL=https://twitter.com/$TWITTER_USER\nIn the above example, process.env.TWITTER_URL would be set to https://twitter.com/nextjs.\nGood to know: If you need to use variable with a $ in the actual value, it needs to be escaped e.g. \\$.\nBundling Environment Variables for the Browser\nNon-NEXT_PUBLIC_ environment variables are only available in the Node.js environment, meaning they aren't accessible to the browser (the client runs in a different environment).", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-2", "text": "In order to make the value of an environment variable accessible in the browser, Next.js can \"inline\" a value, at build time, into the js bundle that is delivered to the client, replacing all references to process.env.[variable] with a hard-coded value. To tell it to do this, you just have to prefix the variable with NEXT_PUBLIC_. For example:\nTerminal NEXT_PUBLIC_ANALYTICS_ID=abcdefghijk\nThis will tell Next.js to replace all references to process.env.NEXT_PUBLIC_ANALYTICS_ID in the Node.js environment with the value from the environment in which you run next build, allowing you to use it anywhere in your code. It will be inlined into any JavaScript sent to the browser.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-3", "text": "Note: After being built, your app will no longer respond to changes to these environment variables. For instance, if you use a Heroku pipeline to promote slugs built in one environment to another environment, or if you build and deploy a single Docker image to multiple environments, all NEXT_PUBLIC_ variables will be frozen with the value evaluated at build time, so these values need to be set appropriately when the project is built. If you need access to runtime environment values, you'll have to setup your own API to provide them to the client (either on demand or during initialization).\npages/index.js import setupAnalyticsService from '../lib/my-analytics-service'\n \n// 'NEXT_PUBLIC_ANALYTICS_ID' can be used here as it's prefixed by 'NEXT_PUBLIC_'.\n// It will be transformed at build time to `setupAnalyticsService('abcdefghijk')`.\nsetupAnalyticsService(process.env.NEXT_PUBLIC_ANALYTICS_ID)\n \nfunction HomePage() {", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-4", "text": "function HomePage() {\n  return <h1>Hello World</h1>\n}\n \nexport default HomePage\nNote that dynamic lookups will not be inlined, such as:\n // This will NOT be inlined, because it uses a variable\nconst varName = 'NEXT_PUBLIC_ANALYTICS_ID'\nsetupAnalyticsService(process.env[varName])\n \n// This will NOT be inlined, because it uses a variable\nconst env = process.env\nsetupAnalyticsService(env.NEXT_PUBLIC_ANALYTICS_ID)\nDefault Environment Variables\nIn general only one .env.local file is needed. However, sometimes you might want to add some defaults for the development (next dev) or production (next start) environment.\nNext.js allows you to set defaults in .env (all environments), .env.development (development environment), and .env.production (production environment).\n.env.local always overrides the defaults set.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-5", "text": ".env.local always overrides the defaults set.\nGood to know: .env, .env.development, and .env.production files should be included in your repository as they define defaults. .env*.local should be added to .gitignore, as those files are intended to be ignored. .env.local is where secrets can be stored.\nEnvironment Variables on Vercel\nWhen deploying your Next.js application to Vercel, Environment Variables can be configured in the Project Settings.\nAll types of Environment Variables should be configured there. Even Environment Variables used in Development \u2013 which can be downloaded onto your local device afterwards.\nIf you've configured Development Environment Variables you can pull them into a .env.local for usage on your local machine using the following command:\nTerminal vercel env pull .env.local\nTest Environment Variables", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-6", "text": "Terminal vercel env pull .env.local\nTest Environment Variables\nApart from development and production environments, there is a 3rd option available: test. In the same way you can set defaults for development or production environments, you can do the same with a .env.test file for the testing environment (though this one is not as common as the previous two). Next.js will not load environment variables from .env.development or .env.production in the testing environment.\nThis one is useful when running tests with tools like jest or cypress where you need to set specific environment vars only for testing purposes. Test default values will be loaded if NODE_ENV is set to test, though you usually don't need to do this manually as testing tools will address it for you.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-7", "text": "There is a small difference between test environment, and both development and production that you need to bear in mind: .env.local won't be loaded, as you expect tests to produce the same results for everyone. This way every test execution will use the same env defaults across different executions by ignoring your .env.local (which is intended to override the default set).\nGood to know: similar to Default Environment Variables, .env.test file should be included in your repository, but .env.test.local shouldn't, as .env*.local are intended to be ignored through .gitignore.\nWhile running unit tests you can make sure to load your environment variables the same way Next.js does by leveraging the loadEnvConfig function from the @next/env package.\n // The below can be used in a Jest global setup file or similar for your testing set-up\nimport { loadEnvConfig } from '@next/env'\n \nexport default async () => {", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "8404cd2451c8-8", "text": "export default async () => {\n  const projectDir = process.cwd()\n  loadEnvConfig(projectDir)\n}\nEnvironment Variable Load Order\nEnvironment variables are looked up in the following places, in order, stopping once the variable is found.\nprocess.env\n.env.$(NODE_ENV).local\n.env.local (Not checked when NODE_ENV is test.)\n.env.$(NODE_ENV)\n.env\nFor example, if NODE_ENV is development and you define a variable in both .env.development.local and .env, the value in .env.development.local will be used.\nGood to know: The allowed values for NODE_ENV are production, development and test.\nGood to know\nIf you are using a /src directory, .env.* files should remain in the root of your project.\nIf the environment variable NODE_ENV is unassigned, Next.js automatically assigns development when running the next dev command, or production for all other commands.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables"}
{"id": "969d964bad5d-0", "text": "Absolute Imports and Module Path Aliases\nExamples\nAbsolute Imports and Aliases\nNext.js has in-built support for the \"paths\" and \"baseUrl\" options of tsconfig.json and jsconfig.json files.\nThese options allow you to alias project directories to absolute paths, making it easier to import modules. For example:\n // before\nimport { Button } from '../../../components/button'\n \n// after\nimport { Button } from '@/components/button'\nGood to know: create-next-app will prompt to configure these options for you.\nAbsolute Imports\nThe baseUrl configuration option allows you to import directly from the root of the project.\nAn example of this configuration:\ntsconfig.json or jsconfig.json {\n  \"compilerOptions\": {\n    \"baseUrl\": \".\"\n  }\n}\ncomponents/button.tsx export default function Button() {\n  return <button>Click me</button>\n}\napp/page.tsx import Button from 'components/button'", "source": "https://nextjs.org/docs/app/building-your-application/configuring/absolute-imports-and-module-aliases"}
{"id": "969d964bad5d-1", "text": "}\napp/page.tsx import Button from 'components/button'\n \nexport default function HomePage() {\n  return (\n    <>\n      <h1>Hello World</h1>\n      <Button />\n    </>\n  )\n}\nModule Aliases\nIn addition to configuring the baseUrl path, you can use the \"paths\" option to \"alias\" module paths.\nFor example, the following configuration maps @/components/* to components/*:\ntsconfig.json or jsconfig.json {\n  \"compilerOptions\": {\n    \"baseUrl\": \".\",\n    \"paths\": {\n      \"@/components/*\": [\"components/*\"]\n    }\n  }\n}\ncomponents/button.tsx export default function Button() {\n  return <button>Click me</button>\n}\napp/page.tsx import Button from '@/components/button'\n \nexport default function HomePage() {\n  return (\n    <>", "source": "https://nextjs.org/docs/app/building-your-application/configuring/absolute-imports-and-module-aliases"}
{"id": "969d964bad5d-2", "text": "export default function HomePage() {\n  return (\n    <>\n      <h1>Hello World</h1>\n      <Button />\n    </>\n  )\n}\nEach of the \"paths\" are relative to the baseUrl location. For example:\n // tsconfig.json or jsconfig.json\n{\n  \"compilerOptions\": {\n    \"baseUrl\": \"src/\",\n    \"paths\": {\n      \"@/styles/*\": [\"styles/*\"],\n      \"@/components/*\": [\"components/*\"]\n    }\n  }\n}\n // pages/index.js\nimport Button from '@/components/button'\nimport '@/styles/styles.css'\nimport Helper from 'utils/helper'\n \nexport default function HomePage() {\n  return (\n    <Helper>\n      <h1>Hello World</h1>\n      <Button />\n    </Helper>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/configuring/absolute-imports-and-module-aliases"}
{"id": "7cbea5741ded-0", "text": "MDX\nMarkdown is a lightweight markup language used to format text. It allows you to write using plain text syntax and convert it to structurally valid HTML. It's commonly used for writing content on websites and blogs.\nYou write...\n I **love** using [Next.js](https://nextjs.org/)\nOutput:\n <p>I <strong>love</strong> using <a href=\"https://nextjs.org/\">Next.js</a></p>\nMDX is a superset of markdown that lets you write JSX directly in your markdown files. It is a powerful way to add dynamic interactivity and embed React components within your content.\nNext.js can support both local MDX content inside your application, as well as remote MDX files fetched dynamically on the server. The Next.js plugin handles transforming Markdown and React components into HTML, including support for usage in Server Components (default in app).\n@next/mdx", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-1", "text": "@next/mdx\nThe @next/mdx package is configured in the next.config.js file at your projects root. It sources data from local files, allowing you to create pages with a .mdx extension, directly in your /pages or /app directory.\nGetting Started\nInstall the @next/mdx package:Terminal npm install @next/mdx @mdx-js/loader @mdx-js/react @types/mdxCreate mdx-components.tsx in the root of your application (the parent folder of app/ or src/):mdx-components.tsx import type { MDXComponents } from 'mdx/types'\n \n// This file allows you to provide custom React components\n// to be used in MDX files. You can import and use any\n// React component you want, including components from\n// other libraries.\n \n// This file is required to use MDX in `app` directory.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-2", "text": "// This file is required to use MDX in `app` directory.\nexport function useMDXComponents(components: MDXComponents): MDXComponents {\n  return {\n    // Allows customizing built-in components, e.g. to add styling.\n    // h1: ({ children }) => <h1 style={{ fontSize: \"100px\" }}>{children}</h1>,\n    ...components,\n  }\n}Update next.config.js to use mdxRs:next.config.js /** @type {import('next').NextConfig} */\nconst nextConfig = {\n  experimental: {\n    mdxRs: true,\n  },\n}\n \nconst withMDX = require('@next/mdx')()\nmodule.exports = withMDX(nextConfig)Add a new file with MDX content to your app directory:app/hello.mdx Hello, Next.js!", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-3", "text": "You can import and use React components in MDX files.Import the MDX file inside a page to display the content:app/page.tsx import HelloWorld from './hello.mdx'\n \nexport default function Page() {\n  return <HelloWorld />\n}\nRemote MDX\nIf your Markdown or MDX files do not live inside your application, you can fetch them dynamically on the server. This is useful for fetching content from a CMS or other data source.\nThere are two popular community packages for fetching MDX content: next-mdx-remote and contentlayer. For example, the following example uses next-mdx-remote:\nGood to know: Please proceed with caution. MDX compiles to JavaScript and is executed on the server. You should only fetch MDX content from a trusted source, otherwise this can lead to remote code execution (RCE).", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-4", "text": "app/page.tsx import { MDXRemote } from 'next-mdx-remote/rsc'\n \nexport default async function Home() {\n  const res = await fetch('https://...')\n  const markdown = await res.text()\n  return <MDXRemote source={markdown} />\n}\nLayouts\nTo share a layout around MDX content, you can use the built-in layouts support with the App Router.\nRemark and Rehype Plugins\nYou can optionally provide remark and rehype plugins to transform the MDX content. For example, you can use remark-gfm to support GitHub Flavored Markdown.\nSince the remark and rehype ecosystem is ESM only, you'll need to use next.config.mjs as the configuration file.\nnext.config.mjs import remarkGfm from 'remark-gfm'\nimport createMDX from '@next/mdx'", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-5", "text": "import createMDX from '@next/mdx'\n \n/** @type {import('next').NextConfig} */\nconst nextConfig = {\n  experimental: {\n    appDir: true,\n  },\n}\n \nconst withMDX = createMDX({\n  options: {\n    extension: /\\.mdx?$/,\n    remarkPlugins: [remarkGfm],\n    rehypePlugins: [],\n    // If you use `MDXProvider`, uncomment the following line.\n    // providerImportSource: \"@mdx-js/react\",\n  },\n})\nexport default withMDX(nextConfig)\nFrontmatter\nFrontmatter is a YAML like key/value pairing that can be used to store data about a page. @next/mdx does not support frontmatter by default, though there are many solutions for adding frontmatter to your MDX content, such as gray-matter.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-6", "text": "To access page metadata with @next/mdx, you can export a meta object from within the .mdx file:\n export const meta = {\n  author: 'Rich Haines',\n}\n \n# My MDX page\nCustom Elements\nOne of the pleasant aspects of using markdown, is that it maps to native HTML elements, making writing fast, and intuitive:\n This is a list in markdown:\n \n- One\n- Two\n- Three\nThe above generates the following HTML:\n <p>This is a list in markdown:</p>\n \n<ul>\n  <li>One</li>\n  <li>Two</li>\n  <li>Three</li>\n</ul>", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-7", "text": "<li>Three</li>\n</ul>\nWhen you want to style your own elements to give a custom feel to your website or application, you can pass in shortcodes. These are your own custom components that map to HTML elements. To do this you use the MDXProvider and pass a components object as a prop. Each object key in the components object maps to a HTML element name.\nTo enable you need to specify providerImportSource: \"@mdx-js/react\" in next.config.js.\nnext.config.js const withMDX = require('@next/mdx')({\n  // ...\n  options: {\n    providerImportSource: '@mdx-js/react',\n  },\n})\nThen setup the provider in your page\npages/index.js import { MDXProvider } from '@mdx-js/react'\nimport Image from 'next/image'\nimport { Heading, InlineCode, Pre, Table, Text } from 'my-components'", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-8", "text": "import { Heading, InlineCode, Pre, Table, Text } from 'my-components'\n \nconst ResponsiveImage = (props) => (\n  <Image\n    alt={props.alt}\n    sizes=\"100vw\"\n    style={{ width: '100%', height: 'auto' }}\n    {...props}\n  />\n)\n \nconst components = {\n  img: ResponsiveImage,\n  h1: Heading.H1,\n  h2: Heading.H2,\n  p: Text,\n  pre: Pre,\n  code: InlineCode,\n}\n \nexport default function Post(props) {\n  return (\n    <MDXProvider components={components}>\n      <main {...props} />\n    </MDXProvider>\n  )\n}", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-9", "text": "<main {...props} />\n    </MDXProvider>\n  )\n}\nIf you use it across the site you may want to add the provider to _app.js so all MDX pages pick up the custom element config.\nDeep Dive: How do you transform markdown into HTML?\nReact does not natively understand Markdown. The markdown plaintext needs to first be transformed into HTML. This can be accomplished with remark and rehype.\nremark is an ecosystem of tools around markdown. rehype is the same, but for HTML. For example, the following code snippet transforms markdown into HTML:\n import { unified } from 'unified'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport rehypeSanitize from 'rehype-sanitize'\nimport rehypeStringify from 'rehype-stringify'\n \nmain()\n \nasync function main() {", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-10", "text": "main()\n \nasync function main() {\n  const file = await unified()\n    .use(remarkParse) // Convert into markdown AST\n    .use(remarkRehype) // Transform to HTML AST\n    .use(rehypeSanitize) // Sanitize HTML input\n    .use(rehypeStringify) // Convert AST into serialized HTML\n    .process('Hello, Next.js!')\n \n  console.log(String(file)) // <p>Hello, Next.js!</p>\n}\nThe remark and rehype ecosystem contains plugins for syntax highlighting, linking headings, generating a table of contents, and more.\nWhen using @next/mdx as shown below, you do not need to use remark or rehype directly, as it is handled for you.\nUsing the Rust-based MDX compiler (Experimental)", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "7cbea5741ded-11", "text": "Using the Rust-based MDX compiler (Experimental)\nNext.js supports a new MDX compiler written in Rust. This compiler is still experimental and is not recommended for production use. To use the new compiler, you need to configure next.config.js when you pass it to withMDX:\nnext.config.js module.exports = withMDX({\n  experimental: {\n    mdxRs: true,\n  },\n})\nHelpful Links\nMDX\n@next/mdx\nremark\nrehype", "source": "https://nextjs.org/docs/app/building-your-application/configuring/mdx"}
{"id": "c6ec912627f5-0", "text": "src Directory\nAs an alternative to having the special Next.js app or pages directories in the root of your project, Next.js also supports the common pattern of placing application code under the src directory.\nThis separates application code from project configuration files which mostly live in the root of a project. Which is preferred by some individuals and teams.\nTo use the src directory, move the app Router folder or pages Router folder to src/app or src/pages respectively.\nGood to know\nThe /public directory should remain in the root of your project.\nConfig files like package.json, next.config.js and tsconfig.json should remain in the root of your project.\n.env.* files should remain in the root of your project.\nsrc/app or src/pages will be ignored if app or pages are present in the root directory.\nIf you're using src, you'll probably also move other application folders such as /components or /lib.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/src-directory"}
{"id": "c6ec912627f5-1", "text": "If you're using Tailwind CSS, you'll need to add the /src prefix to the tailwind.config.js file in the content section.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/src-directory"}
{"id": "f6d31d7ef0e5-0", "text": "Draft ModeStatic rendering is useful when your pages fetch data from a headless CMS. However, it\u2019s not ideal when you\u2019re writing a draft on your headless CMS and want to view the draft immediately on your page. You\u2019d want Next.js to render these pages at request time instead of build time and fetch the draft content instead of the published content. You\u2019d want Next.js to switch to dynamic rendering only for this specific case.\nNext.js has a feature called Draft Mode which solves this problem. Here are instructions on how to use it.\nStep 1: Create and access the Route Handler\nFirst, create a Route Handler. It can have any name - e.g. app/api/draft/route.ts\nThen, import draftMode from next/headers and call the enable() method.\napp/api/draft/route.ts // route handler enabling draft mode\nimport { draftMode } from 'next/headers'", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-1", "text": "import { draftMode } from 'next/headers'\n \nexport async function GET(request: Request) {\n  draftMode().enable()\n  return new Response('Draft mode is enabled')\n}\nThis will set a cookie to enable draft mode. Subsequent requests containing this cookie will trigger Draft Mode changing the behavior for statically generated pages (more on this later).\nYou can test this manually by visiting /api/draft and looking at your browser\u2019s developer tools. Notice the Set-Cookie response header with a cookie named __prerender_bypass.\nSecurely accessing it from your Headless CMS\nIn practice, you\u2019d want to call this Route Handler securely from your headless CMS. The specific steps will vary depending on which headless CMS you\u2019re using, but here are some common steps you could take.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-2", "text": "These steps assume that the headless CMS you\u2019re using supports setting custom draft URLs. If it doesn\u2019t, you can still use this method to secure your draft URLs, but you\u2019ll need to construct and access the draft URL manually.\nFirst, you should create a secret token string using a token generator of your choice. This secret will only be known by your Next.js app and your headless CMS. This secret prevents people who don\u2019t have access to your CMS from accessing draft URLs.\nSecond, if your headless CMS supports setting custom draft URLs, specify the following as the draft URL. This assumes that your Route Handler is located at app/api/draft/route.ts\nTerminal https://<your-site>/api/draft?secret=<token>&slug=<path>\n<your-site> should be your deployment domain.\n<token> should be replaced with the secret token you generated.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-3", "text": "<token> should be replaced with the secret token you generated.\n<path> should be the path for the page that you want to view. If you want to view /posts/foo, then you should use &slug=/posts/foo.\nYour headless CMS might allow you to include a variable in the draft URL so that <path> can be set dynamically based on the CMS\u2019s data like so: &slug=/posts/{entry.fields.slug}\nFinally, in the Route Handler:\nCheck that the secret matches and that the slug parameter exists (if not, the request should fail).\nCall draftMode.enable() to set the cookie.\nThen redirect the browser to the path specified by slug.\napp/api/draft/route.ts // route handler with secret and slug\nimport { draftMode } from 'next/headers'\nimport { redirect } from 'next/navigation'\n \nexport async function GET(request: Request) {\n  // Parse query string parameters", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-4", "text": "export async function GET(request: Request) {\n  // Parse query string parameters\n  const { searchParams } = new URL(request.url)\n  const secret = searchParams.get('secret')\n  const slug = searchParams.get('slug')\n \n  // Check the secret and next parameters\n  // This secret should only be known to this route handler and the CMS\n  if (secret !== 'MY_SECRET_TOKEN' || !slug) {\n    return new Response('Invalid token', { status: 401 })\n  }\n \n  // Fetch the headless CMS to check if the provided `slug` exists\n  // getPostBySlug would implement the required fetching logic to the headless CMS\n  const post = await getPostBySlug(slug)\n \n  // If the slug doesn't exist prevent draft mode from being enabled\n  if (!post) {", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-5", "text": "if (!post) {\n    return new Response('Invalid slug', { status: 401 })\n  }\n \n  // Enable Draft Mode by setting the cookie\n  draftMode().enable()\n \n  // Redirect to the path from the fetched post\n  // We don't redirect to searchParams.slug as that might lead to open redirect vulnerabilities\n  redirect(post.slug)\n}\nIf it succeeds, then the browser will be redirected to the path you want to view with the draft mode cookie.\nStep 2: Update page\nThe next step is to update your page to check the value of draftMode().isEnabled.\nIf you request a page which has the cookie set, then data will be fetched at request time (instead of at build time).\nFurthermore, the value of isEnabled will be true.\napp/page.tsx // page that fetches data\nimport { draftMode } from 'next/headers'", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-6", "text": "import { draftMode } from 'next/headers'\n \nasync function getData() {\n  const { isEnabled } = draftMode()\n \n  const url = isEnabled\n    ? 'https://draft.example.com'\n    : 'https://production.example.com'\n \n  const res = await fetch(url)\n \n  return res.json()\n}\n \nexport default async function Page() {\n  const { title, desc } = await getData()\n \n  return (\n    <main>\n      <h1>{title}</h1>\n      <p>{desc}</p>\n    </main>\n  )\n}\nThat's it! If you access the draft Route Handler (with secret and slug) from your headless CMS or manually, you should now be able to see the draft content. And if you update your draft without publishing, you should be able to view the draft.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-7", "text": "Set this as the draft URL on your headless CMS or access manually, and you should be able to see the draft.\nTerminal https://<your-site>/api/draft?secret=<token>&slug=<path>\nMore Details\nClear the Draft Mode cookie\nBy default, the Draft Mode session ends when the browser is closed.\nTo clear the Draft Mode cookie manually, create a Route Handler that calls draftMode().disable():\napp/api/disable-draft/route.ts import { draftMode } from 'next/headers'\n \nexport async function GET(request: Request) {\n  draftMode().disable()\n  return new Response('Draft mode is disabled')\n}\nThen, send a request to /api/disable-draft to invoke the Route Handler. If calling this route using next/link, you must pass prefetch={false} to prevent accidentally deleting the cookie on prefetch.\nUnique per next build", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "f6d31d7ef0e5-8", "text": "Unique per next build\nA new bypass cookie value will be generated each time you run next build.\nThis ensures that the bypass cookie can\u2019t be guessed.\nGood to know: To test Draft Mode locally over HTTP, your browser will need to allow third-party cookies and local storage access.", "source": "https://nextjs.org/docs/app/building-your-application/configuring/draft-mode"}
{"id": "3a945247eb53-0", "text": "Static Exports\nNext.js enables starting as a static site or Single-Page Application (SPA), then later optionally upgrading to use features that require a server.\nWhen running next build, Next.js generates an HTML file per route. By breaking a strict SPA into individual HTML files, Next.js can avoid loading unnecessary JavaScript code on the client-side, reducing the bundle size and enabling faster page loads.\nSince Next.js supports this static export, it can be deployed and hosted on any web server that can serve HTML/CSS/JS static assets.\nConfiguration\nTo enable a static export, change the output mode inside next.config.js:\nnext.config.js /**\n * @type {import('next').NextConfig}\n */\nconst nextConfig = {\n  output: 'export',\n  // Optional: Add a trailing slash to all paths `/about` -> `/about/`\n  // trailingSlash: true,", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-1", "text": "// trailingSlash: true,\n  // Optional: Change the output directory `out` -> `dist`\n  // distDir: 'dist',\n}\n \nmodule.exports = nextConfig\nAfter running next build, Next.js will produce an out folder which contains the HTML/CSS/JS assets for your application.\nSupported Features\nThe core of Next.js has been designed to support static exports.Server Components\nWhen you run next build to generate a static export, Server Components consumed inside the app directory will run during the build, similar to traditional static-site generation.The resulting component will be rendered into static HTML for the initial page load and a static payload for client navigation between routes. No changes are required for your Server Components when using the static export, unless they consume dynamic server functions.app/page.tsx export default async function Page() {\n  // This fetch will run on the server during `next build`", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-2", "text": "// This fetch will run on the server during `next build`\n  const res = await fetch('https://api.example.com/...')\n  const data = await res.json()\n \n  return <main>...</main>\n}Client Components\nIf you want to perform data fetching on the client, you can use a Client Component with SWR to deduplicate requests.app/other/page.tsx 'use client'\n \nimport useSWR from 'swr'\n \nconst fetcher = (url: string) => fetch(url).then((r) => r.json())\n \nexport default function Page() {\n  const { data, error } = useSWR(\n    `https://jsonplaceholder.typicode.com/posts/1`,\n    fetcher\n  )\n  if (error) return 'Failed to load'\n  if (!data) return 'Loading...'\n \n  return data.title", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-3", "text": "if (!data) return 'Loading...'\n \n  return data.title\n}Since route transitions happen client-side, this behaves like a traditional SPA. For example, the following index route allows you to navigate to different posts on the client:app/page.tsx import Link from 'next/link'\n \nexport default function Page() {\n  return (\n    <>\n      <h1>Index Page</h1>\n      <hr />\n      <ul>\n        <li>\n          <Link href=\"/post/1\">Post 1</Link>\n        </li>\n        <li>\n          <Link href=\"/post/2\">Post 2</Link>\n        </li>\n      </ul>\n    </>\n  )\n}\nImage Optimization", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-4", "text": "</ul>\n    </>\n  )\n}\nImage Optimization\nImage Optimization through next/image can be used with a static export by defining a custom image loader in next.config.js. For example, you can optimize images with a service like Cloudinary:\nnext.config.js /** @type {import('next').NextConfig} */\nconst nextConfig = {\n  output: 'export',\n  images: {\n    loader: 'custom',\n    loaderFile: './app/image.ts',\n  },\n}\n \nmodule.exports = nextConfig\nThis custom loader will define how to fetch images from a remote source. For example, the following loader will construct the URL for Cloudinary:\napp/image.ts export default function cloudinaryLoader({\n  src,\n  width,\n  quality,\n}: {\n  src: string\n  width: number\n  quality?: number\n}) {", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-5", "text": "src: string\n  width: number\n  quality?: number\n}) {\n  const params = ['f_auto', 'c_limit', `w_${width}`, `q_${quality || 'auto'}`]\n  return `https://res.cloudinary.com/demo/image/upload/${params.join(\n    ','\n  )}${src}`\n}\nYou can then use next/image in your application, defining relative paths to the image in Cloudinary:\napp/page.tsx import Image from 'next/image'\n \nexport default function Page() {\n  return <Image alt=\"turtles\" src=\"/turtles.jpg\" width={300} height={300} />\n}\nRoute Handlers", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-6", "text": "}\nRoute Handlers\nRoute Handlers will render a static response when running next build. Only the GET HTTP verb is supported. This can be used to generate static HTML, JSON, TXT, or other files from dynamic or static data. For example:app/data.json/route.ts import { NextResponse } from 'next/server'\n \nexport async function GET() {\n  return NextResponse.json({ name: 'Lee' })\n}The above file app/data.json/route.ts will render to a static file during next build, producing data.json containing { name: 'Lee' }.If you need to read dynamic values from the incoming request, you cannot use a static export.Browser APIs\nClient Components are pre-rendered to HTML during next build. Because Web APIs like window, localStorage, and navigator are not available on the server, you need to safely access these APIs only when running in the browser. For example: 'use client';", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-7", "text": "import { useEffect } from 'react';\n \nexport default function ClientComponent() {\n  useEffect(() => {\n    // You now have access to `window`\n    console.log(window.innerHeight);\n  }, [])\n \n  return ...;\n}\nUnsupported Features\nAfter enabling the static export output mode, all routes inside app are opted-into the following Route Segment Config: export const dynamic = 'error'With this configuration, your application will produce an error if you try to use server functions like headers or cookies, since there is no runtime server. This ensures local development matches the same behavior as a static export. If you need to use server functions, you cannot use a static export.The following additional dynamic features are not supported with a static export:\nrewrites in next.config.js\nredirects in next.config.js\nheaders in next.config.js\nMiddleware\nIncremental Static Regeneration\nDeploying", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-8", "text": "headers in next.config.js\nMiddleware\nIncremental Static Regeneration\nDeploying\nWith a static export, Next.js can be deployed and hosted on any web server that can serve HTML/CSS/JS static assets.\nWhen running next build, Next.js generates the static export into the out folder. Using next export is no longer needed. For example, let's say you have the following routes:\n/\n/blog/[id]\nAfter running next build, Next.js will generate the following files:\n/out/index.html\n/out/404.html\n/out/blog/post-1.html\n/out/blog/post-2.html\nIf you are using a static host like Nginx, you can configure rewrites from incoming requests to the correct files:\nnginx.conf server {\n  listen 80;\n  server_name acme.com;\n \n  root /var/www;\n \n  location / {\n      try_files /out/index.html =404;", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "3a945247eb53-9", "text": "location / {\n      try_files /out/index.html =404;\n  }\n \n  location /blog/ {\n      rewrite ^/blog/(.*)$ /out/blog/$1.html break;\n  }\n \n  error_page 404 /out/404.html;\n  location = /404.html {\n      internal;\n  }\n}\nVersion History\nVersionChangesv13.4.0App Router (Stable) adds enhanced static export support, including using React Server Components and Route Handlers.v13.3.0next export is deprecated and replaced with \"output\": \"export\"", "source": "https://nextjs.org/docs/app/building-your-application/deploying/static-exports"}
{"id": "b2e25b3d03e3-0", "text": "CodemodsCodemods are transformations that run on your codebase programmatically. This allows a large number of changes to be programmatically applied without having to manually go through every file.\nNext.js provides Codemod transformations to help upgrade your Next.js codebase when an API is updated or deprecated.\nUsage\nIn your terminal, navigate (cd) into your project's folder, then run:\nTerminal npx @next/codemod <transform> <path>\nReplacing <transform> and <path> with appropriate values.\ntransform - name of transform\npath - files or directory to transform\n--dry Do a dry-run, no code will be edited\n--print Prints the changed output for comparison\nNext.js Codemods\n13.2\nUse Built-in Font\nbuilt-in-next-font\nTerminal npx @next/codemod@latest built-in-next-font .", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-1", "text": "Terminal npx @next/codemod@latest built-in-next-font .\nThis codemod uninstalls the @next/font package and transforms @next/font imports into the built-in next/font.\nFor example:\n import { Inter } from '@next/font/google'\nTransforms into:\n import { Inter } from 'next/font/google'\n13.0\nRename Next Image Imports\nnext-image-to-legacy-image\nTerminal npx @next/codemod@latest next-image-to-legacy-image .\nSafely renames next/image imports in existing Next.js 10, 11, or 12 applications to next/legacy/image in Next.js 13. Also renames next/future/image to next/image.\nFor example:\npages/index.js import Image1 from 'next/image'\nimport Image2 from 'next/future/image'\n \nexport default function Home() {\n  return (\n    <div>", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-2", "text": "export default function Home() {\n  return (\n    <div>\n      <Image1 src=\"/test.jpg\" width=\"200\" height=\"300\" />\n      <Image2 src=\"/test.png\" width=\"500\" height=\"400\" />\n    </div>\n  )\n}\nTransforms into:\npages/index.js // 'next/image' becomes 'next/legacy/image'\nimport Image1 from 'next/legacy/image'\n// 'next/future/image' becomes 'next/image'\nimport Image2 from 'next/image'\n \nexport default function Home() {\n  return (\n    <div>\n      <Image1 src=\"/test.jpg\" width=\"200\" height=\"300\" />\n      <Image2 src=\"/test.png\" width=\"500\" height=\"400\" />\n    </div>\n  )\n}\nMigrate to the New Image Component\nnext-image-experimental", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-3", "text": ")\n}\nMigrate to the New Image Component\nnext-image-experimental\nTerminal npx @next/codemod@latest next-image-experimental .\nDangerously migrates from next/legacy/image to the new next/image by adding inline styles and removing unused props.\nRemoves layout prop and adds style.\nRemoves objectFit prop and adds style.\nRemoves objectPosition prop and adds style.\nRemoves lazyBoundary prop.\nRemoves lazyRoot prop.\nRemove <a> Tags From Link Components\nnew-link\nTerminal npx @next/codemod@latest new-link .\nRemove <a> tags inside Link Components, or add a legacyBehavior prop to Links that cannot be auto-fixed.\nFor example:\n <Link href=\"/about\">\n  <a>About</a>\n</Link>\n// transforms into\n<Link href=\"/about\">\n  About\n</Link>\n \n<Link href=\"/about\">", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-4", "text": "About\n</Link>\n \n<Link href=\"/about\">\n  <a onClick={() => console.log('clicked')}>About</a>\n</Link>\n// transforms into\n<Link href=\"/about\" onClick={() => console.log('clicked')}>\n  About\n</Link>\nIn cases where auto-fixing can't be applied, the legacyBehavior prop is added. This allows your app to keep functioning using the old behavior for that particular link.\n const Component = () => <a>About</a>\n \n<Link href=\"/about\">\n  <Component />\n</Link>\n// becomes\n<Link href=\"/about\" legacyBehavior>\n  <Component />\n</Link>\n11\nMigrate from CRA\ncra-to-next\nTerminal npx @next/codemod cra-to-next", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-5", "text": "cra-to-next\nTerminal npx @next/codemod cra-to-next\nMigrates a Create React App project to Next.js; creating a Pages Router and necessary config to match behavior. Client-side only rendering is leveraged initially to prevent breaking compatibility due to window usage during SSR and can be enabled seamlessly to allow the gradual adoption of Next.js specific features.\nPlease share any feedback related to this transform in this discussion.\n10\nAdd React imports\nadd-missing-react-import\nTerminal npx @next/codemod add-missing-react-import\nTransforms files that do not import React to include the import in order for the new React JSX transform to work.\nFor example:\nmy-component.js export default class Home extends React.Component {\n  render() {\n    return <div>Hello World</div>\n  }\n}\nTransforms into:\nmy-component.js import React from 'react'\nexport default class Home extends React.Component {", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-6", "text": "my-component.js import React from 'react'\nexport default class Home extends React.Component {\n  render() {\n    return <div>Hello World</div>\n  }\n}\n9\nTransform Anonymous Components into Named Components\nname-default-component\nTerminal npx @next/codemod name-default-component\nVersions 9 and above.\nTransforms anonymous components into named components to make sure they work with Fast Refresh.\nFor example:\nmy-component.js export default function () {\n  return <div>Hello World</div>\n}\nTransforms into:\nmy-component.js export default function MyComponent() {\n  return <div>Hello World</div>\n}\nThe component will have a camel-cased name based on the name of the file, and it also works with arrow functions.\n8\nTransform AMP HOC into page config\nwithamp-to-config\nTerminal npx @next/codemod withamp-to-config", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-7", "text": "withamp-to-config\nTerminal npx @next/codemod withamp-to-config\nTransforms the withAmp HOC into Next.js 9 page configuration.\nFor example:\n // Before\nimport { withAmp } from 'next/amp'\n \nfunction Home() {\n  return <h1>My AMP Page</h1>\n}\n \nexport default withAmp(Home)\n // After\nexport default function Home() {\n  return <h1>My AMP Page</h1>\n}\n \nexport const config = {\n  amp: true,\n}\n6\nUse withRouter\nurl-to-withrouter\nTerminal npx @next/codemod url-to-withrouter\nTransforms the deprecated automatically injected url property on top level pages to using withRouter and the router property it injects. Read more here: https://nextjs.org/docs/messages/url-deprecated\nFor example:", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "b2e25b3d03e3-8", "text": "For example:\nFrom import React from 'react'\nexport default class extends React.Component {\n  render() {\n    const { pathname } = this.props.url\n    return <div>Current pathname: {pathname}</div>\n  }\n}\nTo import React from 'react'\nimport { withRouter } from 'next/router'\nexport default withRouter(\n  class extends React.Component {\n    render() {\n      const { pathname } = this.props.router\n      return <div>Current pathname: {pathname}</div>\n    }\n  }\n)\nThis is one case. All the cases that are transformed (and tested) can be found in the __testfixtures__ directory.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/codemods"}
{"id": "f11f02aeb46b-0", "text": "App Router Incremental Adoption GuideThis guide will help you:\nUpdate your Next.js application from version 12 to version 13\nUpgrade features that work in both the pages and the app directories\nIncrementally migrate your existing application from pages to app\nUpgrading\nNode.js Version\nThe minimum Node.js version is now v16.8. See the Node.js documentation for more information.\nNext.js Version\nTo update to Next.js version 13, run the following command using your preferred package manager:\nTerminal npm install next@latest react@latest react-dom@latest\nESLint Version\nIf you're using ESLint, you need to upgrade your ESLint version:\nTerminal npm install -D eslint-config-next@latest", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-1", "text": "Terminal npm install -D eslint-config-next@latest\nGood to know: You may need to restart the ESLint server in VS Code for the ESLint changes to take effect. Open the Command Palette (cmd+shift+p on Mac; ctrl+shift+p on Windows) and search for ESLint: Restart ESLint Server.\nNext Steps\nAfter you've updated, see the following sections for next steps:\nUpgrade new features: A guide to help you upgrade to new features such as the improved Image and Link Components.\nMigrate from the pages to app directory: A step-by-step guide to help you incrementally migrate from the pages to the app directory.\nUpgrading New Features\nNext.js 13 introduced the new App Router with new features and conventions. The new Router is available in the app directory and co-exists with the pages directory.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-2", "text": "Upgrading to Next.js 13 does not require using the new App Router. You can continue using pages with new features that work in both directories, such as the updated Image component, Link component, Script component, and Font optimization.\n<Image/> Component\nNext.js 12 introduced new improvements to the Image Component with a temporary import: next/future/image. These improvements included less client-side JavaScript, easier ways to extend and style images, better accessibility, and native browser lazy loading.\nIn version 13, this new behavior is now the default for next/image.\nThere are two codemods to help you migrate to the new Image Component:\nnext-image-to-legacy-image codemod: Safely and automatically renames next/image imports to next/legacy/image. Existing components will maintain the same behavior.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-3", "text": "next-image-experimental codemod: Dangerously adds inline styles and removes unused props. This will change the behavior of existing components to match the new defaults. To use this codemod, you need to run the next-image-to-legacy-image codemod first.\n<Link> Component\nThe <Link> Component no longer requires manually adding an <a> tag as a child. This behavior was added as an experimental option in version 12.2 and is now the default. In Next.js 13, <Link> always renders <a> and allows you to forward props to the underlying tag.\nFor example:\n import Link from 'next/link'\n \n// Next.js 12: `<a>` has to be nested otherwise it's excluded\n<Link href=\"/about\">\n  <a>About</a>\n</Link>\n \n// Next.js 13: `<Link>` always renders `<a>` under the hood", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-4", "text": "// Next.js 13: `<Link>` always renders `<a>` under the hood\n<Link href=\"/about\">\n  About\n</Link>\nTo upgrade your links to Next.js 13, you can use the new-link codemod.\n<Script> Component\nThe behavior of next/script has been updated to support both pages and app, but some changes need to be made to ensure a smooth migration:\nMove any beforeInteractive scripts you previously included in _document.js to the root layout file (app/layout.tsx).\nThe experimental worker strategy does not yet work in app and scripts denoted with this strategy will either have to be removed or modified to use a different strategy (e.g. lazyOnload).\nonLoad, onReady, and onError handlers will not work in Server Components so make sure to move them to a Client Component or remove them altogether.\nFont Optimization", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-5", "text": "Font Optimization\nPreviously, Next.js helped you optimize fonts by inlining font CSS. Version 13 introduces the new next/font module which gives you the ability to customize your font loading experience while still ensuring great performance and privacy. next/font is supported in both the pages and app directories.\nWhile inlining CSS still works in pages, it does not work in app. You should use next/font instead.\nSee the Font Optimization page to learn how to use next/font.\nMigrating from pages to app\n\ud83c\udfa5 Watch: Learn how to incrementally adopt the App Router \u2192 YouTube (16 minutes).\nMoving to the App Router may be the first time using React features that Next.js builds on top of such as Server Components, Suspense, and more. When combined with new Next.js features such as special files and layouts, migration means new concepts, mental models, and behavioral changes to learn.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-6", "text": "We recommend reducing the combined complexity of these updates by breaking down your migration into smaller steps. The app directory is intentionally designed to work simultaneously with the pages directory to allow for incremental page-by-page migration.\nThe app directory supports nested routes and layouts. Learn more.\nUse nested folders to define routes and a special page.js file to make a route segment publicly accessible. Learn more.\nSpecial file conventions are used to create UI for each route segment. The most common special files are page.js and layout.js.\nUse page.js to define UI unique to a route.\nUse layout.js to define UI that is shared across multiple routes.\n.js, .jsx, or .tsx file extensions can be used for special files.\nYou can colocate other files inside the app directory such as components, styles, tests, and more. Learn more.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-7", "text": "Data fetching functions like getServerSideProps and getStaticProps have been replaced with a new API inside app. getStaticPaths has been replaced with generateStaticParams.\npages/_app.js and pages/_document.js have been replaced with a single app/layout.js root layout. Learn more.\npages/_error.js has been replaced with more granular error.js special files. Learn more.\npages/404.js has been replaced with the not-found.js file.\npages/api/* currently remain inside the pages directory.\nStep 1: Creating the app directory\nUpdate to the latest Next.js version (requires 13.4 or greater):\n npm install next@latest\nThen, create a new app directory at the root of your project (or src/ directory).\nStep 2: Creating a Root Layout\nCreate a new app/layout.tsx file inside the app directory. This is a root layout that will apply to all routes inside app.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-8", "text": "app/layout.tsx export default function RootLayout({\n  // Layouts must accept a children prop.\n  // This will be populated with nested layouts or pages\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n    </html>\n  )\n}\nThe app directory must include a root layout.\nThe root layout must define <html>, and <body> tags since Next.js does not automatically create them\nThe root layout replaces the pages/_app.tsx and pages/_document.tsx files.\n.js, .jsx, or .tsx extensions can be used for layout files.\nTo manage <head> HTML elements, you can use the built-in SEO support:\napp/layout.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: 'Home',", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-9", "text": "export const metadata: Metadata = {\n  title: 'Home',\n  description: 'Welcome to Next.js',\n}\nMigrating _document.js and _app.js\nIf you have an existing _app or _document file, you can copy the contents (e.g. global styles) to the root layout (app/layout.tsx). Styles in app/layout.tsx will not apply to pages/*. You should keep _app/_document while migrating to prevent your pages/* routes from breaking. Once fully migrated, you can then safely delete them.\nIf you are using any React Context providers, they will need to be moved to a Client Component.\nMigrating the getLayout() pattern to Layouts (Optional)\nNext.js recommended adding a property to Page components to achieve per-page layouts in the pages directory. This pattern can be replaced with native support for nested layouts in the app directory.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-10", "text": "See before and after exampleBeforecomponents/DashboardLayout.js export default function DashboardLayout({ children }) {\n  return (\n    <div>\n      <h2>My Dashboard</h2>\n      {children}\n    </div>\n  )\n}pages/dashboard/index.js import DashboardLayout from '../components/DashboardLayout'\n \nexport default function Page() {\n  return <p>My Page</p>\n}\n \nPage.getLayout = function getLayout(page) {\n  return <DashboardLayout>{page}</DashboardLayout>\n}After\nRemove the Page.getLayout property from pages/dashboard/index.js and follow the steps for migrating pages to the app directory.\napp/dashboard/page.js export default function Page() {\n  return <p>My Page</p>\n}\nMove the contents of DashboardLayout into a new Client Component to retain pages directory behavior.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-11", "text": "}\nMove the contents of DashboardLayout into a new Client Component to retain pages directory behavior.\napp/dashboard/DashboardLayout.js 'use client' // this directive should be at top of the file, before any imports.\n \n// This is a Client Component\nexport default function DashboardLayout({ children }) {\n  return (\n    <div>\n      <h2>My Dashboard</h2>\n      {children}\n    </div>\n  )\n}\nImport the DashboardLayout into a new layout.js file inside the app directory.\napp/dashboard/layout.js import DashboardLayout from './DashboardLayout'\n \n// This is a Server Component\nexport default function Layout({ children }) {\n  return <DashboardLayout>{children}</DashboardLayout>\n}\nYou can incrementally move non-interactive parts of DashboardLayout.js (Client Component) into layout.js (Server Component) to reduce the amount of component JavaScript you send to the client.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-12", "text": "Step 3: Migrating next/head\nIn the pages directory, the next/head React component is used to manage <head> HTML elements such as title and meta . In the app directory, next/head is replaced with the new built-in SEO support.\nBefore:\npages/index.tsx import Head from 'next/head'\n \nexport default function Page() {\n  return (\n    <>\n      <Head>\n        <title>My page title</title>\n      </Head>\n    </>\n  )\n}\nAfter:\napp/page.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: 'My Page Title',\n}\n \nexport default function Page() {\n  return '...'\n}\nSee all metadata options.\nStep 4: Migrating Pages", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-13", "text": "}\nSee all metadata options.\nStep 4: Migrating Pages\nPages in the app directory are Server Components by default. This is different from the pages directory where pages are Client Components.\nData fetching has changed in app. getServerSideProps, getStaticProps and getInitialProps have been replaced for a simpler API.\nThe app directory uses nested folders to define routes and a special page.js file to make a route segment publicly accessible.\npages Directoryapp DirectoryRouteindex.jspage.js/about.jsabout/page.js/aboutblog/[slug].jsblog/[slug]/page.js/blog/post-1\nWe recommend breaking down the migration of a page into two main steps:\nStep 1: Move the default exported Page Component into a new Client Component.\nStep 2: Import the new Client Component into a new page.js file inside the app directory.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-14", "text": "Good to know: This is the easiest migration path because it has the most comparable behavior to the pages directory.\nStep 1: Create a new Client Component\nCreate a new separate file inside the app directory (i.e. app/home-page.tsx or similar) that exports a Client Component. To define Client Components, add the 'use client' directive to the top of the file (before any imports).\nMove the default exported page component from pages/index.js to app/home-page.tsx.\napp/home-page.tsx 'use client'\n \n// This is a Client Component. It receives data as props and\n// has access to state and effects just like Page components\n// in the `pages` directory.\nexport default function HomePage({ recentPosts }) {\n  return (\n    <div>\n      {recentPosts.map((post) => (\n        <div key={post.id}>{post.title}</div>\n      ))}", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-15", "text": "<div key={post.id}>{post.title}</div>\n      ))}\n    </div>\n  )\n}\nStep 2: Create a new page\nCreate a new app/page.tsx file inside the app directory. This is a Server Component by default.\nImport the home-page.tsx Client Component into the page.\nIf you were fetching data in pages/index.js, move the data fetching logic directly into the Server Component using the new data fetching APIs. See the data fetching upgrade guide for more details.\napp/page.tsx // Import your Client Component\nimport HomePage from './home-page'\n \nasync function getPosts() {\n  const res = await fetch('https://...')\n  const posts = await res.json()\n  return posts\n}\n \nexport default async function Page() {\n  // Fetch data directly in a Server Component\n  const recentPosts = await getPosts()", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-16", "text": "// Fetch data directly in a Server Component\n  const recentPosts = await getPosts()\n  // Forward fetched data to your Client Component\n  return <HomePage recentPosts={recentPosts} />\n}\nIf your previous page used useRouter, you'll need to update to the new routing hooks. Learn more.\nStart your development server and visit http://localhost:3000. You should see your existing index route, now served through the app directory.\nStep 5: Migrating Routing Hooks\nA new router has been added to support the new behavior in the app directory.\nIn app, you should use the three new hooks imported from next/navigation: useRouter(), usePathname(), and useSearchParams().\nThe new useRouter hook is imported from next/navigation and has different behavior to the useRouter hook in pages which is imported from next/router.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-17", "text": "The useRouter hook imported from next/router is not supported in the app directory but can continue to be used in the pages directory.\nThe new useRouter does not return the pathname string. Use the separate usePathname hook instead.\nThe new useRouter does not return the query object. Use the separate useSearchParams hook instead.\nYou can use useSearchParams and usePathname together to listen to page changes. See the Router Events section for more details.\nThese new hooks are only supported in Client Components. They cannot be used in Server Components.\napp/example-client-component.tsx 'use client'\n \nimport { useRouter, usePathname, useSearchParams } from 'next/navigation'\n \nexport default function ExampleClientComponent() {\n  const router = useRouter()\n  const pathname = usePathname()\n  const searchParams = useSearchParams()\n \n  // ...\n}\nIn addition, the new useRouter hook has the following changes:", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-18", "text": "// ...\n}\nIn addition, the new useRouter hook has the following changes:\nisFallback has been removed because fallback has been replaced.\nThe locale, locales, defaultLocales, domainLocales values have been removed because built-in i18n Next.js features are no longer necessary in the app directory. Learn more about i18n.\nbasePath has been removed. The alternative will not be part of useRouter. It has not yet been implemented.\nasPath has been removed because the concept of as has been removed from the new router.\nisReady has been removed because it is no longer necessary. During static rendering, any component that uses the useSearchParams() hook will skip the prerendering step and instead be rendered on the client at runtime.\nView the useRouter() API reference.\nStep 6: Migrating Data Fetching Methods", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-19", "text": "View the useRouter() API reference.\nStep 6: Migrating Data Fetching Methods\nThe pages directory uses getServerSideProps and getStaticProps to fetch data for pages. Inside the app directory, these previous data fetching functions are replaced with a simpler API built on top of fetch() and async React Server Components.\napp/page.tsx export default async function Page() {\n  // This request should be cached until manually invalidated.\n  // Similar to `getStaticProps`.\n  // `force-cache` is the default and can be omitted.\n  const staticData = await fetch(`https://...`, { cache: 'force-cache' })\n \n  // This request should be refetched on every request.\n  // Similar to `getServerSideProps`.\n  const dynamicData = await fetch(`https://...`, { cache: 'no-store' })", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-20", "text": "// This request should be cached with a lifetime of 10 seconds.\n  // Similar to `getStaticProps` with the `revalidate` option.\n  const revalidatedData = await fetch(`https://...`, {\n    next: { revalidate: 10 },\n  })\n \n  return <div>...</div>\n}\nServer-side Rendering (getServerSideProps)\nIn the pages directory, getServerSideProps is used to fetch data on the server and forward props to the default exported React component in the file. The initial HTML for the page is prerendered from the server, followed by \"hydrating\" the page in the browser (making it interactive).\npages/dashboard.js // `pages` directory\n \nexport async function getServerSideProps() {\n  const res = await fetch(`https://...`)\n  const projects = await res.json()", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-21", "text": "const projects = await res.json()\n \n  return { props: { projects } }\n}\n \nexport default function Dashboard({ projects }) {\n  return (\n    <ul>\n      {projects.map((project) => (\n        <li key={project.id}>{project.name}</li>\n      ))}\n    </ul>\n  )\n}\nIn the app directory, we can colocate our data fetching inside our React components using Server Components. This allows us to send less JavaScript to the client, while maintaining the rendered HTML from the server.\nBy setting the cache option to no-store, we can indicate that the fetched data should never be cached. This is similar to getServerSideProps in the pages directory.\napp/dashboard/page.tsx // `app` directory\n \n// This function can be named anything\nasync function getProjects() {", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-22", "text": "// This function can be named anything\nasync function getProjects() {\n  const res = await fetch(`https://...`, { cache: 'no-store' })\n  const projects = await res.json()\n \n  return projects\n}\n \nexport default async function Dashboard() {\n  const projects = await getProjects()\n \n  return (\n    <ul>\n      {projects.map((project) => (\n        <li key={project.id}>{project.name}</li>\n      ))}\n    </ul>\n  )\n}\nAccessing Request Object\nIn the pages directory, you can retrieve request-based data based on the Node.js HTTP API.\nFor example, you can retrieve the req object from getServerSideProps and use it to retrieve the request's cookies and headers.\npages/index.js // `pages` directory\n \nexport async function getServerSideProps({ req, query }) {", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-23", "text": "export async function getServerSideProps({ req, query }) {\n  const authHeader = req.getHeaders()['authorization'];\n  const theme = req.cookies['theme'];\n \n  return { props: { ... }}\n}\n \nexport default function Page(props) {\n  return ...\n}\nThe app directory exposes new read-only functions to retrieve request data:\nheaders(): Based on the Web Headers API, and can be used inside Server Components to retrieve request headers.\ncookies(): Based on the Web Cookies API, and can be used inside Server Components to retrieve cookies.\napp/page.tsx // `app` directory\nimport { cookies, headers } from 'next/headers'\n \nasync function getData() {\n  const authHeader = headers().get('authorization')\n \n  return '...'\n}\n \nexport default async function Page() {", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-24", "text": "return '...'\n}\n \nexport default async function Page() {\n  // You can use `cookies()` or `headers()` inside Server Components\n  // directly or in your data fetching function\n  const theme = cookies().get('theme')\n  const data = await getData()\n  return '...'\n}\nStatic Site Generation (getStaticProps)\nIn the pages directory, the getStaticProps function is used to pre-render a page at build time. This function can be used to fetch data from an external API or directly from a database, and pass this data down to the entire page as it's being generated during the build.\npages/index.js // `pages` directory\n \nexport async function getStaticProps() {\n  const res = await fetch(`https://...`)\n  const projects = await res.json()\n \n  return { props: { projects } }\n}", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-25", "text": "return { props: { projects } }\n}\n \nexport default function Index({ projects }) {\n  return projects.map((project) => <div>{project.name}</div>)\n}\nIn the app directory, data fetching with fetch() will default to cache: 'force-cache', which will cache the request data until manually invalidated. This is similar to getStaticProps in the pages directory.\napp/page.js // `app` directory\n \n// This function can be named anything\nasync function getProjects() {\n  const res = await fetch(`https://...`)\n  const projects = await res.json()\n \n  return projects\n}\n \nexport default async function Index() {\n  const projects = await getProjects()\n \n  return projects.map((project) => <div>{project.name}</div>)\n}\nDynamic paths (getStaticPaths)", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-26", "text": "}\nDynamic paths (getStaticPaths)\nIn the pages directory, the getStaticPaths function is used to define the dynamic paths that should be pre-rendered at build time.\npages/posts/[id].js // `pages` directory\nimport PostLayout from '@/components/post-layout'\n \nexport async function getStaticPaths() {\n  return {\n    paths: [{ params: { id: '1' } }, { params: { id: '2' } }],\n  }\n}\n \nexport async function getStaticProps({ params }) {\n  const res = await fetch(`https://.../posts/${params.id}`)\n  const post = await res.json()\n \n  return { props: { post } }\n}\n \nexport default function Post({ post }) {\n  return <PostLayout post={post} />\n}", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-27", "text": "return <PostLayout post={post} />\n}\nIn the app directory, getStaticPaths is replaced with generateStaticParams.\ngenerateStaticParams behaves similarly to getStaticPaths, but has a simplified API for returning route parameters and can be used inside layouts. The return shape of generateStaticParams is an array of segments instead of an array of nested param objects or a string of resolved paths.\napp/posts/[id]/page.js // `app` directory\nimport PostLayout from '@/components/post-layout'\n \nexport async function generateStaticParams() {\n  return [{ id: '1' }, { id: '2' }]\n}\n \nasync function getPost(params) {\n  const res = await fetch(`https://.../posts/${params.id}`)\n  const post = await res.json()\n \n  return post\n}\n \nexport default async function Post({ params }) {", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-28", "text": "return post\n}\n \nexport default async function Post({ params }) {\n  const post = await getPost(params)\n \n  return <PostLayout post={post} />\n}\nUsing the name generateStaticParams is more appropriate than getStaticPaths for the new model in the app directory. The get prefix is replaced with a more descriptive generate, which sits better alone now that getStaticProps and getServerSideProps are no longer necessary. The Paths suffix is replaced by Params, which is more appropriate for nested routing with multiple dynamic segments.\nReplacing fallback\nIn the pages directory, the fallback property returned from getStaticPaths is used to define the behavior of a page that isn't pre-rendered at build time. This property can be set to true to show a fallback page while the page is being generated, false to show a 404 page, or blocking to generate the page at request time.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-29", "text": "pages/posts/[id].js // `pages` directory\n \nexport async function getStaticPaths() {\n  return {\n    paths: [],\n    fallback: 'blocking'\n  };\n}\n \nexport async function getStaticProps({ params }) {\n  ...\n}\n \nexport default function Post({ post }) {\n  return ...\n}\nIn the app directory the config.dynamicParams property controls how params outside of generateStaticParams are handled:\ntrue: (default) Dynamic segments not included in generateStaticParams are generated on demand.\nfalse: Dynamic segments not included in generateStaticParams will return a 404.\nThis replaces the fallback: true | false | 'blocking' option of getStaticPaths in the pages directory. The fallback: 'blocking' option is not included in dynamicParams because the difference between 'blocking' and true is negligible with streaming.\napp/posts/[id]/page.js // `app` directory", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-30", "text": "app/posts/[id]/page.js // `app` directory\n \nexport const dynamicParams = true;\n \nexport async function generateStaticParams() {\n  return [...]\n}\n \nasync function getPost(params) {\n  ...\n}\n \nexport default async function Post({ params }) {\n  const post = await getPost(params);\n \n  return ...\n}\nWith dynamicParams set to true (the default), when a route segment is requested that hasn't been generated, it will be server-rendered and cached as static data on success.\nIncremental Static Regeneration (getStaticProps with revalidate)\nIn the pages directory, the getStaticProps function allows you to add a revalidate field to automatically regenerate a page after a certain amount of time. This is called Incremental Static Regeneration (ISR) and helps you update static content without redeploying.\npages/index.js // `pages` directory", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-31", "text": "pages/index.js // `pages` directory\n \nexport async function getStaticProps() {\n  const res = await fetch(`https://.../posts`)\n  const posts = await res.json()\n \n  return {\n    props: { posts },\n    revalidate: 60,\n  }\n}\n \nexport default function Index({ posts }) {\n  return (\n    <Layout>\n      <PostList posts={posts} />\n    </Layout>\n  )\n}\nIn the app directory, data fetching with fetch() can use revalidate, which will cache the request for the specified amount of seconds.\napp/page.js // `app` directory\n \nasync function getPosts() {\n  const res = await fetch(`https://.../posts`, { next: { revalidate: 60 } })\n  const data = await res.json()\n \n  return data.posts\n}", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-32", "text": "const data = await res.json()\n \n  return data.posts\n}\n \nexport default async function PostList() {\n  const posts = await getPosts()\n \n  return posts.map((post) => <div>{post.name}</div>)\n}\nAPI Routes\nAPI Routes continue to work in the pages/api directory without any changes. However, they have been replaced by Route Handlers in the app directory.\nRoute Handlers allow you to create custom request handlers for a given route using the Web Request and Response APIs.\napp/api/route.ts export async function GET(request: Request) {}\nGood to know: If you previously used API routes to call an external API from the client, you can now use Server Components instead to securely fetch data. Learn more about data fetching.\nStep 7: Styling", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-33", "text": "Step 7: Styling\nIn the pages directory, global stylesheets are restricted to only pages/_app.js. With the app directory, this restriction has been lifted. Global styles can be added to any layout, page, or component.\nCSS Modules\nTailwind CSS\nGlobal Styles\nCSS-in-JS\nExternal Stylesheets\nSass\nTailwind CSS\nIf you're using Tailwind CSS, you'll need to add the app directory to your tailwind.config.js file:\ntailwind.config.js module.exports = {\n  content: [\n    './app/**/*.{js,ts,jsx,tsx,mdx}', // <-- Add this line\n    './pages/**/*.{js,ts,jsx,tsx,mdx}',\n    './components/**/*.{js,ts,jsx,tsx,mdx}',\n  ],\n}\nYou'll also need to import your global styles in your app/layout.js file:", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "f11f02aeb46b-34", "text": "}\nYou'll also need to import your global styles in your app/layout.js file:\napp/layout.js import '../styles/globals.css'\n \nexport default function RootLayout({ children }) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n    </html>\n  )\n}\nLearn more about styling with Tailwind CSS\nCodemods\nNext.js provides Codemod transformations to help upgrade your codebase when a feature is deprecated. See Codemods for more information.", "source": "https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration"}
{"id": "04cf7f2db2da-0", "text": "create-next-app\nThe easiest way to get started with Next.js is by using create-next-app. This CLI tool enables you to quickly start building a new Next.js application, with everything set up for you.\nYou can create a new app using the default Next.js template, or by using one of the official Next.js examples.\nInteractive\nYou can create a new project interactively by running:\nTerminal npx create-next-app@latest\nTerminal yarn create next-app\nTerminal pnpm create next-app\nYou will then be asked the following prompts:\nTerminal What is your project named?  my-app\nWould you like to use TypeScript?  No / Yes\nWould you like to use ESLint?  No / Yes\nWould you like to use Tailwind CSS?  No / Yes\nWould you like to use `src/` directory?  No / Yes\nWould you like to use App Router? (recommended)  No / Yes", "source": "https://nextjs.org/docs/app/api-reference/create-next-app"}
{"id": "04cf7f2db2da-1", "text": "Would you like to use App Router? (recommended)  No / Yes\nWould you like to customize the default import alias?  No / Yes\nOnce you've answered the prompts, a new project will be created with the correct configuration depending on your answers.\nNon-interactive\nYou can also pass command line arguments to set up a new project non-interactively.\nFurther, you can negate default options by prefixing them with --no- (e.g. --no-eslint).\nSee create-next-app --help:\nTerminal Usage: create-next-app <project-directory> [options]\n \nOptions:\n  -V, --version                        output the version number\n  --ts, --typescript\n \n    Initialize as a TypeScript project. (default)\n \n  --js, --javascript\n \n    Initialize as a JavaScript project.\n \n  --tailwind\n \n    Initialize with Tailwind CSS config. (default)", "source": "https://nextjs.org/docs/app/api-reference/create-next-app"}
{"id": "04cf7f2db2da-2", "text": "--tailwind\n \n    Initialize with Tailwind CSS config. (default)\n \n  --eslint\n \n    Initialize with ESLint config.\n \n  --app\n \n    Initialize as an App Router project.\n \n  --src-dir\n \n    Initialize inside a `src/` directory.\n \n  --import-alias <alias-to-configure>\n \n    Specify import alias to use (default \"@/*\").\n \n  --use-npm\n \n    Explicitly tell the CLI to bootstrap the app using npm\n \n  --use-pnpm\n \n    Explicitly tell the CLI to bootstrap the app using pnpm\n \n  --use-yarn\n \n    Explicitly tell the CLI to bootstrap the app using Yarn\n \n  -e, --example [name]|[github-url]", "source": "https://nextjs.org/docs/app/api-reference/create-next-app"}
{"id": "04cf7f2db2da-3", "text": "-e, --example [name]|[github-url]\n \n    An example to bootstrap the app with. You can use an example name\n    from the official Next.js repo or a public GitHub URL. The URL can use\n    any branch and/or subdirectory\n \n  --example-path <path-to-example>\n \n    In a rare case, your GitHub URL might contain a branch name with\n    a slash (e.g. bug/fix-1) and the path to the example (e.g. foo/bar).\n    In this case, you must specify the path to the example separately:\n    --example-path foo/bar\n \n  --reset-preferences\n \n    Explicitly tell the CLI to reset any stored preferences\n \n  -h, --help                           output usage information\nWhy use Create Next App?", "source": "https://nextjs.org/docs/app/api-reference/create-next-app"}
{"id": "04cf7f2db2da-4", "text": "-h, --help                           output usage information\nWhy use Create Next App?\ncreate-next-app allows you to create a new Next.js app within seconds. It is officially maintained by the creators of Next.js, and includes a number of benefits:\nInteractive Experience: Running npx create-next-app@latest (with no arguments) launches an interactive experience that guides you through setting up a project.\nZero Dependencies: Initializing a project is as quick as one second. Create Next App has zero dependencies.\nOffline Support: Create Next App will automatically detect if you're offline and bootstrap your project using your local package cache.\nSupport for Examples: Create Next App can bootstrap your application using an example from the Next.js examples collection (e.g. npx create-next-app --example api-routes) or any public GitHub repository.", "source": "https://nextjs.org/docs/app/api-reference/create-next-app"}
{"id": "04cf7f2db2da-5", "text": "Tested: The package is part of the Next.js monorepo and tested using the same integration test suite as Next.js itself, ensuring it works as expected with every release.", "source": "https://nextjs.org/docs/app/api-reference/create-next-app"}
{"id": "176a5d9303fb-0", "text": "Edge Runtime\nThe Next.js Edge Runtime is based on standard Web APIs, it supports the following APIs:\nNetwork APIs\nAPIDescriptionBlobRepresents a blobfetchFetches a resourceFetchEventRepresents a fetch eventFileRepresents a fileFormDataRepresents form dataHeadersRepresents HTTP headersRequestRepresents an HTTP requestResponseRepresents an HTTP responseURLSearchParamsRepresents URL search parametersWebSocketRepresents a websocket connection\nEncoding APIs\nAPIDescriptionatobDecodes a base-64 encoded stringbtoaEncodes a string in base-64TextDecoderDecodes a Uint8Array into a stringTextDecoderStreamChainable decoder for streamsTextEncoderEncodes a string into a Uint8ArrayTextEncoderStreamChainable encoder for streams\nStream APIs", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-1", "text": "Stream APIs\nAPIDescriptionReadableStreamRepresents a readable streamReadableStreamBYOBReaderRepresents a reader of a ReadableStreamReadableStreamDefaultReaderRepresents a reader of a ReadableStreamTransformStreamRepresents a transform streamWritableStreamRepresents a writable streamWritableStreamDefaultWriterRepresents a writer of a WritableStream\nCrypto APIs\nAPIDescriptioncryptoProvides access to the cryptographic functionality of the platformCryptoKeyRepresents a cryptographic keySubtleCryptoProvides access to common cryptographic primitives, like hashing, signing, encryption or decryption\nWeb Standard APIs", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-2", "text": "APIDescriptionAbortControllerAllows you to abort one or more DOM requests as and when desiredArrayRepresents an array of valuesArrayBufferRepresents a generic, fixed-length raw binary data bufferAtomicsProvides atomic operations as static methodsBigIntRepresents a whole number with arbitrary precisionBigInt64ArrayRepresents a typed array of 64-bit signed integersBigUint64ArrayRepresents a typed array of 64-bit unsigned integersBooleanRepresents a logical entity and can have two values: true and falseclearIntervalCancels a timed, repeating action which was previously established by a call to setInterval()clearTimeoutCancels a timed, repeating action which was previously established by a call to setTimeout()consoleProvides access to the browser's debugging consoleDataViewRepresents a generic view of an ArrayBufferDateRepresents a single moment in time in a platform-independent formatdecodeURIDecodes a Uniform Resource Identifier (URI) previously created by encodeURI or by a similar routinedecodeURIComponentDecodes", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-3", "text": "Identifier (URI) previously created by encodeURI or by a similar routinedecodeURIComponentDecodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent or by a similar routineDOMExceptionRepresents an error that occurs in the DOMencodeURIEncodes a Uniform Resource Identifier (URI) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the characterencodeURIComponentEncodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the characterErrorRepresents an error when trying to execute a statement or accessing a propertyEvalErrorRepresents an error that occurs regarding the global function eval()Float32ArrayRepresents a typed array of 32-bit floating point numbersFloat64ArrayRepresents a typed array of 64-bit floating point numbersFunctionRepresents a functionInfinityRepresents the mathematical Infinity", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-4", "text": "typed array of 64-bit floating point numbersFunctionRepresents a functionInfinityRepresents the mathematical Infinity valueInt8ArrayRepresents a typed array of 8-bit signed integersInt16ArrayRepresents a typed array of 16-bit signed integersInt32ArrayRepresents a typed array of 32-bit signed integersIntlProvides access to internationalization and localization functionalityisFiniteDetermines whether a value is a finite numberisNaNDetermines whether a value is NaN or notJSONProvides functionality to convert JavaScript values to and from the JSON formatMapRepresents a collection of values, where each value may occur only onceMathProvides access to mathematical functions and constantsNumberRepresents a numeric valueObjectRepresents the object that is the base of all JavaScript objectsparseFloatParses a string argument and returns a floating point numberparseIntParses a string argument and returns an integer of the specified radixPromiseRepresents the eventual completion (or failure) of an asynchronous operation, and its resulting valueProxyRepresents", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-5", "text": "the eventual completion (or failure) of an asynchronous operation, and its resulting valueProxyRepresents an object that is used to define custom behavior for fundamental operations (e.g. property lookup, assignment, enumeration, function invocation, etc)queueMicrotaskQueues a microtask to be executedRangeErrorRepresents an error when a value is not in the set or range of allowed valuesReferenceErrorRepresents an error when a non-existent variable is referencedReflectProvides methods for interceptable JavaScript operationsRegExpRepresents a regular expression, allowing you to match combinations of charactersSetRepresents a collection of values, where each value may occur only oncesetIntervalRepeatedly calls a function, with a fixed time delay between each callsetTimeoutCalls a function or evaluates an expression after a specified number of millisecondsSharedArrayBufferRepresents a generic, fixed-length raw binary data bufferStringRepresents a sequence of charactersstructuredCloneCreates a deep copy of a valueSymbolRepresents a unique and immutable data type that is used", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-6", "text": "a deep copy of a valueSymbolRepresents a unique and immutable data type that is used as the key of an object propertySyntaxErrorRepresents an error when trying to interpret syntactically invalid codeTypeErrorRepresents an error when a value is not of the expected typeUint8ArrayRepresents a typed array of 8-bit unsigned integersUint8ClampedArrayRepresents a typed array of 8-bit unsigned integers clamped to 0-255Uint32ArrayRepresents a typed array of 32-bit unsigned integersURIErrorRepresents an error when a global URI handling function was used in a wrong wayURLRepresents an object providing static methods used for creating object URLsURLPatternRepresents a URL patternURLSearchParamsRepresents a collection of key/value pairsWeakMapRepresents a collection of key/value pairs in which the keys are weakly referencedWeakSetRepresents a collection of objects in which each object may occur only onceWebAssemblyProvides access to WebAssembly", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-7", "text": "Next.js Specific Polyfills\nAsyncLocalStorage\nEnvironment Variables\nYou can use process.env to access Environment Variables for both next dev and next build.\nUnsupported APIs\nThe Edge Runtime has some restrictions including:\nNative Node.js APIs are not supported. For example, you can't read or write to the filesystem.\nnode_modules can be used, as long as they implement ES Modules and do not use native Node.js APIs.\nCalling require directly is not allowed. Use ES Modules instead.\nThe following JavaScript language features are disabled, and will not work:\nAPIDescriptionevalEvaluates JavaScript code represented as a stringnew Function(evalString)Creates a new function with the code provided as an argumentWebAssembly.compileCompiles a WebAssembly module from a buffer sourceWebAssembly.instantiateCompiles and instantiates a WebAssembly module from a buffer source", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "176a5d9303fb-8", "text": "In rare cases, your code could contain (or import) some dynamic code evaluation statements which can not be reached at runtime and which can not be removed by treeshaking.\nYou can relax the check to allow specific files with your Middleware or Edge API Route exported configuration:\n export const config = {\n  runtime: 'edge', // for Edge API Routes only\n  unstable_allowDynamic: [\n    // allows a single file\n    '/lib/utilities.js',\n    // use a glob to allow anything in the function-bind 3rd party module\n    '/node_modules/function-bind/**',\n  ],\n}\nunstable_allowDynamic is a glob, or an array of globs, ignoring dynamic code evaluation for specific files. The globs are relative to your application root folder.\nBe warned that if these statements are executed on the Edge, they will throw and cause a runtime error.", "source": "https://nextjs.org/docs/app/api-reference/edge"}
{"id": "10a35df783d3-0", "text": "Next.js CLI\nThe Next.js CLI allows you to start, build, and export your application.\nTo get a list of the available CLI commands, run the following command inside your project directory:\nTerminal npx next -h\n(npx comes with npm 5.2+ and higher)\nThe output should look like this:\nTerminal Usage\n  $ next <command>\n \nAvailable commands\n  build, start, export, dev, lint, telemetry, info\n \nOptions\n  --version, -v   Version number\n  --help, -h      Displays this message\n \nFor more information run a command with the --help flag\n  $ next build --help\nYou can pass any node arguments to next commands:\nTerminal NODE_OPTIONS='--throw-deprecation' next\nNODE_OPTIONS='-r esm' next\nNODE_OPTIONS='--inspect' next", "source": "https://nextjs.org/docs/app/api-reference/next-cli"}
{"id": "10a35df783d3-1", "text": "NODE_OPTIONS='-r esm' next\nNODE_OPTIONS='--inspect' next\nGood to know: Running next without a command is the same as running next dev\nBuild\nnext build creates an optimized production build of your application. The output displays information about each route.\nSize \u2013 The number of assets downloaded when navigating to the page client-side. The size for each route only includes its dependencies.\nFirst Load JS \u2013 The number of assets downloaded when visiting the page from the server. The amount of JS shared by all is shown as a separate metric.\nBoth of these values are compressed with gzip. The first load is indicated by green, yellow, or red. Aim for green for performant applications.\nYou can enable production profiling for React with the --profile flag in next build. This requires Next.js 9.5:\nTerminal next build --profile\nAfter that, you can use the profiler in the same way as you would in development.", "source": "https://nextjs.org/docs/app/api-reference/next-cli"}
{"id": "10a35df783d3-2", "text": "After that, you can use the profiler in the same way as you would in development.\nYou can enable more verbose build output with the --debug flag in next build. This requires Next.js 9.5.3:\nTerminal next build --debug\nWith this flag enabled additional build output like rewrites, redirects, and headers will be shown.\nDevelopment\nnext dev starts the application in development mode with hot-code reloading, error reporting, and more:\nThe application will start at http://localhost:3000 by default. The default port can be changed with -p, like so:\nTerminal npx next dev -p 4000\nOr using the PORT environment variable:\nTerminal PORT=4000 npx next dev\nGood to know: PORT cannot be set in .env as booting up the HTTP server happens before any other code is initialized.", "source": "https://nextjs.org/docs/app/api-reference/next-cli"}
{"id": "10a35df783d3-3", "text": "You can also set the hostname to be different from the default of 0.0.0.0, this can be useful for making the application available for other devices on the network. The default hostname can be changed with -H, like so:\nTerminal npx next dev -H 192.168.1.2\nProduction\nnext start starts the application in production mode. The application should be compiled with next build first.\nThe application will start at http://localhost:3000 by default. The default port can be changed with -p, like so:\nTerminal npx next start -p 4000\nOr using the PORT environment variable:\nTerminal PORT=4000 npx next start\nGood to know:\n-PORT cannot be set in .env as booting up the HTTP server happens before any other code is initialized.\nnext start cannot be used with output: 'standalone' or output: 'export'.\nKeep Alive Timeout", "source": "https://nextjs.org/docs/app/api-reference/next-cli"}
{"id": "10a35df783d3-4", "text": "Keep Alive Timeout\nWhen deploying Next.js behind a downstream proxy (e.g. a load-balancer like AWS ELB/ALB) it's important to configure Next's underlying HTTP server with keep-alive timeouts that are larger than the downstream proxy's timeouts. Otherwise, once a keep-alive timeout is reached for a given TCP connection, Node.js will immediately terminate that connection without notifying the downstream proxy. This results in a proxy error whenever it attempts to reuse a connection that Node.js has already terminated.\nTo configure the timeout values for the production Next.js server, pass --keepAliveTimeout (in milliseconds) to next start, like so:\nTerminal npx next start --keepAliveTimeout 70000\nLint\nnext lint runs ESLint for all files in the pages/, app/, components/, lib/, and src/ directories. It also\nprovides a guided setup to install any required dependencies if ESLint is not already configured in\nyour application.", "source": "https://nextjs.org/docs/app/api-reference/next-cli"}
{"id": "10a35df783d3-5", "text": "your application.\nIf you have other directories that you would like to lint, you can specify them using the --dir\nflag:\nTerminal next lint --dir utils\nTelemetry\nNext.js collects completely anonymous telemetry data about general usage.\nParticipation in this anonymous program is optional, and you may opt-out if you'd not like to share any information.\nTo learn more about Telemetry, please read this document.\nNext Info\nnext info prints relevant details about the current system which can be used to report Next.js bugs.\nThis information includes Operating System platform/arch/version, Binaries (Node.js, npm, Yarn, pnpm) and npm package versions (next, react, react-dom).\nRunning the following in your project's root directory:\nTerminal next info\nwill give you information like this example:\nTerminal  \n    Operating System:\n      Platform: linux\n      Arch: x64", "source": "https://nextjs.org/docs/app/api-reference/next-cli"}
{"id": "10a35df783d3-6", "text": "Terminal  \n    Operating System:\n      Platform: linux\n      Arch: x64\n      Version: #22-Ubuntu SMP Fri Nov 5 13:21:36 UTC 2021\n    Binaries:\n      Node: 16.13.0\n      npm: 8.1.0\n      Yarn: 1.22.17\n      pnpm: 6.24.2\n    Relevant packages:\n      next: 12.0.8\n      react: 17.0.2\n      react-dom: 17.0.2\n \nThis information should then be pasted into GitHub Issues.", "source": "https://nextjs.org/docs/app/api-reference/next-cli"}
{"id": "b153dcbac54c-0", "text": "Font Module\nThis API reference will help you understand how to use next/font/google and next/font/local. For features and usage, please see the Optimizing Fonts page.\nFont Function Arguments\nFor usage, review Google Fonts and Local Fonts.\nKeyfont/googlefont/localTypeRequiredsrcString or Array of ObjectsYesweightString or ArrayRequired/OptionalstyleString or Array-subsetsArray of Strings-axesArray of Strings-displayString-preloadBoolean-fallbackArray of Strings-adjustFontFallbackBoolean or String-variableString-declarationsArray of Objects-\nsrc\nThe path of the font file as a string or an array of objects (with type Array<{path: string, weight?: string, style?: string}>) relative to the directory where the font loader function is called.\nUsed in next/font/local\nRequired\nExamples:\nsrc:'./fonts/my-font.woff2' where my-font.woff2 is placed in a directory named fonts inside the app directory", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-1", "text": "src:[{path: './inter/Inter-Thin.ttf', weight: '100',},{path: './inter/Inter-Regular.ttf',weight: '400',},{path: './inter/Inter-Bold-Italic.ttf', weight: '700',style: 'italic',},]\nif the font loader function is called in app/page.tsx using src:'../styles/fonts/my-font.ttf', then my-font.ttf is placed in styles/fonts at the root of the project\nweight\nThe font weight with the following possibilities:\nA string with possible values of the weights available for the specific font or a range of values if it's a variable font\nAn array of weight values if the font is not a variable google font. It applies to next/font/google only.\nUsed in next/font/google and next/font/local\nRequired if the font being used is not variable\nExamples:", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-2", "text": "Required if the font being used is not variable\nExamples:\nweight: '400': A string for a single weight value - for the font Inter, the possible values are '100', '200', '300', '400', '500', '600', '700', '800', '900' or 'variable' where 'variable' is the default)\nweight: '100 900': A string for the range between 100 and 900 for a variable font\nweight: ['100','400','900']: An array of 3 possible values for a non variable font\nstyle\nThe font style with the following possibilities:\nA string value with default value of 'normal'\nAn array of style values if the font is not a variable google font. It applies to next/font/google only.\nUsed in next/font/google and next/font/local\nOptional\nExamples:\nstyle: 'italic': A string - it can be normal or italic for next/font/google", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-3", "text": "style: 'italic': A string - it can be normal or italic for next/font/google\nstyle: 'oblique': A string - it can take any value for next/font/local but is expected to come from standard font styles\nstyle: ['italic','normal']: An array of 2 values for next/font/google - the values are from normal and italic\nsubsets\nThe font subsets defined by an array of string values with the names of each subset you would like to be preloaded. Fonts specified via subsets will have a link preload tag injected into the head when the preload option is true, which is the default.\nUsed in next/font/google\nOptional\nExamples:\nsubsets: ['latin']: An array with the subset latin\nYou can find a list of all subsets on the Google Fonts page for your font.\naxes", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-4", "text": "You can find a list of all subsets on the Google Fonts page for your font.\naxes\nSome variable fonts have extra axes that can be included. By default, only the font weight is included to keep the file size down. The possible values of axes depend on the specific font.\nUsed in next/font/google\nOptional\nExamples:\naxes: ['slnt']: An array with value slnt for the Inter variable font which has slnt as additional axes as shown here. You can find the possible axes values for your font by using the filter on the Google variable fonts page and looking for axes other than wght\ndisplay\nThe font display with possible string values of 'auto', 'block', 'swap', 'fallback' or 'optional' with default value of 'swap'.\nUsed in next/font/google and next/font/local\nOptional\nExamples:\ndisplay: 'optional': A string assigned to the optional value\npreload", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-5", "text": "Optional\nExamples:\ndisplay: 'optional': A string assigned to the optional value\npreload\nA boolean value that specifies whether the font should be preloaded or not. The default is true.\nUsed in next/font/google and next/font/local\nOptional\nExamples:\npreload: false\nfallback\nThe fallback font to use if the font cannot be loaded. An array of strings of fallback fonts with no default.\nOptional\nUsed in next/font/google and next/font/local\nExamples:\nfallback: ['system-ui', 'arial']: An array setting the fallback fonts to system-ui or arial\nadjustFontFallback\nFor next/font/google: A boolean value that sets whether an automatic fallback font should be used to reduce Cumulative Layout Shift. The default is true.", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-6", "text": "For next/font/local: A string or boolean false value that sets whether an automatic fallback font should be used to reduce Cumulative Layout Shift. The possible values are 'Arial', 'Times New Roman' or false. The default is 'Arial'.\nUsed in next/font/google and next/font/local\nOptional\nExamples:\nadjustFontFallback: false: for ``next/font/google`\nadjustFontFallback: 'Times New Roman': for next/font/local\nvariable\nA string value to define the CSS variable name to be used if the style is applied with the CSS variable method.\nUsed in next/font/google and next/font/local\nOptional\nExamples:\nvariable: '--my-font': The CSS variable --my-font is declared\ndeclarations\nAn array of font face descriptor key-value pairs that define the generated @font-face further.\nUsed in next/font/local\nOptional\nExamples:\ndeclarations: [{ prop: 'ascent-override', value: '90%' }]", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-7", "text": "declarations: [{ prop: 'ascent-override', value: '90%' }]\nApplying Styles\nYou can apply the font styles in three ways:\nclassName\nstyle\nCSS Variables\nclassName\nReturns a read-only CSS className for the loaded font to be passed to an HTML element.\n <p className={inter.className}>Hello, Next.js!</p>\nstyle\nReturns a read-only CSS style object for the loaded font to be passed to an HTML element, including style.fontFamily to access the font family name and fallback fonts.\n <p style={inter.style}>Hello World</p>\nCSS Variables\nIf you would like to set your styles in an external style sheet and specify additional options there, use the CSS variable method.\nIn addition to importing the font, also import the CSS file where the CSS variable is defined and set the variable option of the font loader object as follows:", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-8", "text": "app/page.tsx import { Inter } from 'next/font/google'\nimport styles from '../styles/component.module.css'\n \nconst inter = Inter({\n  variable: '--font-inter',\n})\nTo use the font, set the className of the parent container of the text you would like to style to the font loader's variable value and the className of the text to the styles property from the external CSS file.\napp/page.tsx <main className={inter.variable}>\n  <p className={styles.text}>Hello World</p>\n</main>\nDefine the text selector class in the component.module.css CSS file as follows:\nstyles/component.module.css .text {\n  font-family: var(--font-inter);\n  font-weight: 200;\n  font-style: italic;\n}", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-9", "text": "font-weight: 200;\n  font-style: italic;\n}\nIn the example above, the text Hello World is styled using the Inter font and the generated font fallback with font-weight: 200 and font-style: italic.\nUsing a font definitions file\nEvery time you call the localFont or Google font function, that font will be hosted as one instance in your application. Therefore, if you need to use the same font in multiple places, you should load it in one place and import the related font object where you need it. This is done using a font definitions file.\nFor example, create a fonts.ts file in a styles folder at the root of your app directory.\nThen, specify your font definitions as follows:\nstyles/fonts.ts import { Inter, Lora, Source_Sans_Pro } from 'next/font/google'\nimport localFont from 'next/font/local'\n \n// define your variable fonts\nconst inter = Inter()", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-10", "text": "// define your variable fonts\nconst inter = Inter()\nconst lora = Lora()\n// define 2 weights of a non-variable font\nconst sourceCodePro400 = Source_Sans_Pro({ weight: '400' })\nconst sourceCodePro700 = Source_Sans_Pro({ weight: '700' })\n// define a custom local font where GreatVibes-Regular.ttf is stored in the styles folder\nconst greatVibes = localFont({ src: './GreatVibes-Regular.ttf' })\n \nexport { inter, lora, sourceCodePro400, sourceCodePro700, greatVibes }\nYou can now use these definitions in your code as follows:\napp/page.tsx import { inter, lora, sourceCodePro700, greatVibes } from '../styles/fonts'\n \nexport default function Page() {\n  return (\n    <div>", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-11", "text": "export default function Page() {\n  return (\n    <div>\n      <p className={inter.className}>Hello world using Inter font</p>\n      <p style={lora.style}>Hello world using Lora font</p>\n      <p className={sourceCodePro700.className}>\n        Hello world using Source_Sans_Pro font with weight 700\n      </p>\n      <p className={greatVibes.className}>My title in Great Vibes font</p>\n    </div>\n  )\n}\nTo make it easier to access the font definitions in your code, you can define a path alias in your tsconfig.json or jsconfig.json files as follows:\ntsconfig.json {\n  \"compilerOptions\": {\n    \"paths\": {\n      \"@/fonts\": [\"./styles/fonts\"]\n    }\n  }\n}\nYou can now import any font definition as follows:", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "b153dcbac54c-12", "text": "}\n  }\n}\nYou can now import any font definition as follows:\napp/about/page.tsx import { greatVibes, sourceCodePro400 } from '@/fonts'\nVersion Changes\nVersionChangesv13.2.0@next/font renamed to next/font. Installation no longer required.v13.0.0@next/font was added.", "source": "https://nextjs.org/docs/app/api-reference/components/font"}
{"id": "0cbd170b2a92-0", "text": "<Image>\nExamples\nImage Component\nThis API reference will help you understand how to use props and configuration options available for the Image Component. For features and usage, please see the Image Component page.\napp/page.js import Image from 'next/image'\n \nexport default function Page() {\n  return (\n    <Image\n      src=\"/profile.png\"\n      width={500}\n      height={500}\n      alt=\"Picture of the author\"\n    />\n  )\n}\nProps\nHere's a summary of the props available for the Image Component:", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-1", "text": "}\nProps\nHere's a summary of the props available for the Image Component:\nPropExampleTypeRequiredsrcsrc=\"/profile.png\"StringYeswidthwidth={500}Integer (px)Yesheightheight={500}Integer (px)Yesaltalt=\"Picture of the author\"StringYesloaderloader={imageLoader}Function-fillfill={true}Boolean-sizessizes=\"(max-width: 768px) 100vw\"String-qualityquality={80}Integer (1-100)-prioritypriority={true}Boolean-placeholderplaceholder=\"blur\"String-stylestyle={{objectFit: \"contain\"}}Object-onLoadingCompleteonLoadingComplete={img => done())}Function-onLoadonLoad={event => done())}Function-onErroronError(event => fail()}Function-loadingloading=\"lazy\"String-blurDataURLblurDataURL=\"data:image/jpeg...\"String-\nRequired Props\nThe Image Component requires the following properties: src, width, height, and alt.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-2", "text": "The Image Component requires the following properties: src, width, height, and alt.\napp/page.js import Image from 'next/image'\n \nexport default function Page() {\n  return (\n    <div>\n      <Image\n        src=\"/profile.png\"\n        width={500}\n        height={500}\n        alt=\"Picture of the author\"\n      />\n    </div>\n  )\n}\nsrc\nMust be one of the following:\nA statically imported image file\nA path string. This can be either an absolute external URL, or an internal path depending on the loader prop.\nWhen using an external URL, you must add it to remotePatterns in next.config.js.\nwidth\nThe width property represents the rendered width in pixels, so it will affect how large the image appears.\nRequired, except for statically imported images or images with the fill property.\nheight", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-3", "text": "Required, except for statically imported images or images with the fill property.\nheight\nThe height property represents the rendered height in pixels, so it will affect how large the image appears.\nRequired, except for statically imported images or images with the fill property.\nalt\nThe alt property is used to describe the image for screen readers and search engines. It is also the fallback text if images have been disabled or an error occurs while loading the image.\nIt should contain text that could replace the image without changing the meaning of the page. It is not meant to supplement the image and should not repeat information that is already provided in the captions above or below the image.\nIf the image is purely decorative or not intended for the user, the alt property should be an empty string (alt=\"\").\nLearn more\nOptional Props", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-4", "text": "Learn more\nOptional Props\nThe <Image /> component accepts a number of additional properties beyond those which are required. This section describes the most commonly-used properties of the Image component. Find details about more rarely-used properties in the Advanced Props section.\nloader\nA custom function used to resolve image URLs.\nA loader is a function returning a URL string for the image, given the following parameters:\nsrc\nwidth\nquality\nHere is an example of using a custom loader:\n 'use client'\n \nimport Image from 'next/image'\n \nconst imageLoader = ({ src, width, quality }) => {\n  return `https://example.com/${src}?w=${width}&q=${quality || 75}`\n}\n \nexport default function Page() {\n  return (\n    <Image\n      loader={imageLoader}\n      src=\"me.png\"\n      alt=\"Picture of the author\"\n      width={500}", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-5", "text": "alt=\"Picture of the author\"\n      width={500}\n      height={500}\n    />\n  )\n}\nGood to know: Using props like loader, which accept a function, require using Client Components to serialize the provided function.\nAlternatively, you can use the loaderFile configuration in next.config.js to configure every instance of next/image in your application, without passing a prop.\nfill\n fill={true} // {true} | {false}\nA boolean that causes the image to fill the parent element instead of setting width and height.\nThe parent element must assign position: \"relative\", position: \"fixed\", or position: \"absolute\" style.\nBy default, the img element will automatically be assigned the position: \"absolute\" style.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-6", "text": "By default, the img element will automatically be assigned the position: \"absolute\" style.\nThe default image fit behavior will stretch the image to fit the container. You may prefer to set object-fit: \"contain\" for an image which is letterboxed to fit the container and preserve aspect ratio.\nAlternatively, object-fit: \"cover\" will cause the image to fill the entire container and be cropped to preserve aspect ratio. For this to look correct, the overflow: \"hidden\" style should be assigned to the parent element.\nFor more information, see also:\nposition\nobject-fit\nobject-position\nsizes\nA string that provides information about how wide the image will be at different breakpoints. The value of sizes will greatly affect performance for images using fill or which are styled to have a responsive size.\nThe sizes property serves two important purposes related to image performance:", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-7", "text": "The sizes property serves two important purposes related to image performance:\nFirst, the value of sizes is used by the browser to determine which size of the image to download, from next/image's automatically-generated source set. When the browser chooses, it does not yet know the size of the image on the page, so it selects an image that is the same size or larger than the viewport. The sizes property allows you to tell the browser that the image will actually be smaller than full screen. If you don't specify a sizes value in an image with the fill property, a default value of 100vw (full screen width) is used.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-8", "text": "Second, the sizes property configures how next/image automatically generates an image source set. If no sizes value is present, a small source set is generated, suitable for a fixed-size image. If sizes is defined, a large source set is generated, suitable for a responsive image. If the sizes property includes sizes such as 50vw, which represent a percentage of the viewport width, then the source set is trimmed to not include any values which are too small to ever be necessary.\nFor example, if you know your styling will cause an image to be full-width on mobile devices, in a 2-column layout on tablets, and a 3-column layout on desktop displays, you should include a sizes property such as the following:\n import Image from 'next/image'\n \nexport default function Page() {\n  return (\n    <div className=\"grid-element\">\n      <Image\n        fill\n        src=\"/example.png\"", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-9", "text": "<Image\n        fill\n        src=\"/example.png\"\n        sizes=\"(max-width: 768px) 100vw, (max-width: 1200px) 50vw, 33vw\"\n      />\n    </div>\n  )\n}\nThis example sizes could have a dramatic effect on performance metrics. Without the 33vw sizes, the image selected from the server would be 3 times as wide as it needs to be. Because file size is proportional to the square of the width, without sizes the user would download an image that's 9 times larger than necessary.\nLearn more about srcset and sizes:\nweb.dev\nmdn\nquality\n quality={75} // {number 1-100}\nThe quality of the optimized image, an integer between 1 and 100, where 100 is the best quality and therefore largest file size. Defaults to 75.\npriority", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-10", "text": "priority\n priority={false} // {false} | {true}\nWhen true, the image will be considered high priority and\npreload. Lazy loading is automatically disabled for images using priority.\nYou should use the priority property on any image detected as the Largest Contentful Paint (LCP) element. It may be appropriate to have multiple priority images, as different images may be the LCP element for different viewport sizes.\nShould only be used when the image is visible above the fold. Defaults to false.\nplaceholder\n placeholder = 'empty' // {empty} | {blur}\nA placeholder to use while the image is loading. Possible values are blur or empty. Defaults to empty.\nWhen blur, the blurDataURL property will be used as the placeholder. If src is an object from a static import and the imported image is .jpg, .png, .webp, or .avif, then blurDataURL will be automatically populated.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-11", "text": "For dynamic images, you must provide the blurDataURL property. Solutions such as Plaiceholder can help with base64 generation.\nWhen empty, there will be no placeholder while the image is loading, only empty space.\nTry it out:\nDemo the blur placeholder\nDemo the shimmer effect with blurDataURL prop\nDemo the color effect with blurDataURL prop\nAdvanced Props\nIn some cases, you may need more advanced usage. The <Image /> component optionally accepts the following advanced properties.\nstyle\nAllows passing CSS styles to the underlying image element.\ncomponents/ProfileImage.js const imageStyle = {\n  borderRadius: '50%',\n  border: '1px solid #fff',\n}\n \nexport default function ProfileImage() {\n  return <Image src=\"...\" style={imageStyle} />\n}", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-12", "text": "return <Image src=\"...\" style={imageStyle} />\n}\nRemember that the required width and height props can interact with your styling. If you use styling to modify an image's width, you should also style its height to auto to preserve its intrinsic aspect ratio, or your image will be distorted.\nonLoadingComplete\n 'use client'\n \n<Image onLoadingComplete={(img) => console.log(img.naturalWidth)} />\nA callback function that is invoked once the image is completely loaded and the placeholder has been removed.\nThe callback function will be called with one argument, a reference to the underlying <img> element.\nGood to know: Using props like onLoadingComplete, which accept a function, require using Client Components to serialize the provided function.\nonLoad\n <Image onLoad={(e) => console.log(e.target.naturalWidth)} />\nA callback function that is invoked when the image is loaded.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-13", "text": "A callback function that is invoked when the image is loaded.\nThe load event might occur before the image placeholder is removed and the image is fully decoded. If you want to wait until the image has fully loaded, use onLoadingComplete instead.\nGood to know: Using props like onLoad, which accept a function, require using Client Components to serialize the provided function.\nonError\n <Image onError={(e) => console.error(e.target.id)} />\nA callback function that is invoked if the image fails to load.\nGood to know: Using props like onError, which accept a function, require using Client Components to serialize the provided function.\nloading\nRecommendation: This property is only meant for advanced use cases. Switching an image to load with eager will normally hurt performance. We recommend using the priority property instead, which will eagerly preload the image.\n loading = 'lazy' // {lazy} | {eager}", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-14", "text": "loading = 'lazy' // {lazy} | {eager}\nThe loading behavior of the image. Defaults to lazy.\nWhen lazy, defer loading the image until it reaches a calculated distance from\nthe viewport.\nWhen eager, load the image immediately.\nLearn more about the loading attribute.\nblurDataURL\nA Data URL to\nbe used as a placeholder image before the src image successfully loads. Only takes effect when combined\nwith placeholder=\"blur\".\nMust be a base64-encoded image. It will be enlarged and blurred, so a very small image (10px or\nless) is recommended. Including larger images as placeholders may harm your application performance.\nTry it out:\nDemo the default blurDataURL prop\nDemo the shimmer effect with blurDataURL prop\nDemo the color effect with blurDataURL prop\nYou can also generate a solid color Data URL to match the image.\nunoptimized", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-15", "text": "You can also generate a solid color Data URL to match the image.\nunoptimized\n unoptimized = {false} // {false} | {true}\nWhen true, the source image will be served as-is instead of changing quality,\nsize, or format. Defaults to false.\n import Image from 'next/image'\n \nconst UnoptimizedImage = (props) => {\n  return <Image {...props} unoptimized />\n}\nSince Next.js 12.3.0, this prop can be assigned to all images by updating next.config.js with the following configuration:\nnext.config.js module.exports = {\n  images: {\n    unoptimized: true,\n  },\n}\nOther Props\nOther properties on the <Image /> component will be passed to the underlying\nimg element with the exception of the following:\nsrcSet. Use Device Sizes instead.\ndecoding. It is always \"async\".\nConfiguration Options", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-16", "text": "decoding. It is always \"async\".\nConfiguration Options\nIn addition to props, you can configure the Image Component in next.config.js. The following options are available:\nremotePatterns\nTo protect your application from malicious users, configuration is required in order to use external images. This ensures that only external images from your account can be served from the Next.js Image Optimization API. These external images can be configured with the remotePatterns property in your next.config.js file, as shown below:\nnext.config.js module.exports = {\n  images: {\n    remotePatterns: [\n      {\n        protocol: 'https',\n        hostname: 'example.com',\n        port: '',\n        pathname: '/account123/**',\n      },\n    ],\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-17", "text": "pathname: '/account123/**',\n      },\n    ],\n  },\n}\nGood to know: The example above will ensure the src property of next/image must start with https://example.com/account123/. Any other protocol, hostname, port, or unmatched path will respond with 400 Bad Request.\nBelow is another example of the remotePatterns property in the next.config.js file:\nnext.config.js module.exports = {\n  images: {\n    remotePatterns: [\n      {\n        protocol: 'https',\n        hostname: '**.example.com',\n      },\n    ],\n  },\n}\nGood to know: The example above will ensure the src property of next/image must start with https://img1.example.com or https://me.avatar.example.com or any number of subdomains. Any other protocol or unmatched hostname will respond with 400 Bad Request.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-18", "text": "Wildcard patterns can be used for both pathname and hostname and have the following syntax:\n* match a single path segment or subdomain\n** match any number of path segments at the end or subdomains at the beginning\nThe ** syntax does not work in the middle of the pattern.\ndomains\nWarning: We recommend configuring strict remotePatterns instead of domains in order to protect your application from malicious users. Only use domains if you own all the content served from the domain.\nSimilar to remotePatterns, the domains configuration can be used to provide a list of allowed hostnames for external images.\nHowever, the domains configuration does not support wildcard pattern matching and it cannot restrict protocol, port, or pathname.\nBelow is an example of the domains property in the next.config.js file:\nnext.config.js module.exports = {\n  images: {\n    domains: ['assets.acme.com'],\n  },\n}\nloaderFile", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-19", "text": "domains: ['assets.acme.com'],\n  },\n}\nloaderFile\nIf you want to use a cloud provider to optimize images instead of using the Next.js built-in Image Optimization API, you can configure the loaderFile in your next.config.js like the following:\nnext.config.js module.exports = {\n  images: {\n    loader: 'custom',\n    loaderFile: './my/image/loader.js',\n  },\n}\nThis must point to a file relative to the root of your Next.js application. The file must export a default function that returns a string, for example:\n 'use client'\n \nexport default function myImageLoader({ src, width, quality }) {\n  return `https://example.com/${src}?w=${width}&q=${quality || 75}`\n}\nAlternatively, you can use the loader prop to configure each instance of next/image.\nExamples:\nCustom Image Loader Configuration", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-20", "text": "Examples:\nCustom Image Loader Configuration\nGood to know: Customizing the image loader file, which accepts a function, require using Client Components to serialize the provided function.\nAdvanced\nThe following configuration is for advanced use cases and is usually not necessary. If you choose to configure the properties below, you will override any changes to the Next.js defaults in future updates.\ndeviceSizes\nIf you know the expected device widths of your users, you can specify a list of device width breakpoints using the deviceSizes property in next.config.js. These widths are used when the next/image component uses sizes prop to ensure the correct image is served for user's device.\nIf no configuration is provided, the default below is used.\nnext.config.js module.exports = {\n  images: {\n    deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-21", "text": "},\n}\nimageSizes\nYou can specify a list of image widths using the images.imageSizes property in your next.config.js file. These widths are concatenated with the array of device sizes to form the full array of sizes used to generate image srcsets.\nThe reason there are two separate lists is that imageSizes is only used for images which provide a sizes prop, which indicates that the image is less than the full width of the screen. Therefore, the sizes in imageSizes should all be smaller than the smallest size in deviceSizes.\nIf no configuration is provided, the default below is used.\nnext.config.js module.exports = {\n  images: {\n    imageSizes: [16, 32, 48, 64, 96, 128, 256, 384],\n  },\n}\nformats\nThe default Image Optimization API will automatically detect the browser's supported image formats via the request's Accept header.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-22", "text": "If the Accept head matches more than one of the configured formats, the first match in the array is used. Therefore, the array order matters. If there is no match (or the source image is animated), the Image Optimization API will fallback to the original image's format.\nIf no configuration is provided, the default below is used.\nnext.config.js module.exports = {\n  images: {\n    formats: ['image/webp'],\n  },\n}\nYou can enable AVIF support with the following configuration.\nnext.config.js module.exports = {\n  images: {\n    formats: ['image/avif', 'image/webp'],\n  },\n}\nGood to know:\nAVIF generally takes 20% longer to encode but it compresses 20% smaller compared to WebP. This means that the first time an image is requested, it will typically be slower and then subsequent requests that are cached will be faster.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-23", "text": "If you self-host with a Proxy/CDN in front of Next.js, you must configure the Proxy to forward the Accept header.\nCaching Behavior\nThe following describes the caching algorithm for the default loader. For all other loaders, please refer to your cloud provider's documentation.\nImages are optimized dynamically upon request and stored in the <distDir>/cache/images directory. The optimized image file will be served for subsequent requests until the expiration is reached. When a request is made that matches a cached but expired file, the expired image is served stale immediately. Then the image is optimized again in the background (also called revalidation) and saved to the cache with the new expiration date.\nThe cache status of an image can be determined by reading the value of the x-nextjs-cache response header. The possible values are the following:\nMISS - the path is not in the cache (occurs at most once, on the first visit)", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-24", "text": "STALE - the path is in the cache but exceeded the revalidate time so it will be updated in the background\nHIT - the path is in the cache and has not exceeded the revalidate time\nThe expiration (or rather Max Age) is defined by either the minimumCacheTTL configuration or the upstream image Cache-Control header, whichever is larger. Specifically, the max-age value of the Cache-Control header is used. If both s-maxage and max-age are found, then s-maxage is preferred. The max-age is also passed-through to any downstream clients including CDNs and browsers.\nYou can configure minimumCacheTTL to increase the cache duration when the upstream image does not include Cache-Control header or the value is very low.\nYou can configure deviceSizes and imageSizes to reduce the total number of possible generated images.\nYou can configure formats to disable multiple formats in favor of a single image format.\nminimumCacheTTL", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-25", "text": "minimumCacheTTL\nYou can configure the Time to Live (TTL) in seconds for cached optimized images. In many cases, it's better to use a Static Image Import which will automatically hash the file contents and cache the image forever with a Cache-Control header of immutable.\nnext.config.js module.exports = {\n  images: {\n    minimumCacheTTL: 60,\n  },\n}\nThe expiration (or rather Max Age) of the optimized image is defined by either the minimumCacheTTL or the upstream image Cache-Control header, whichever is larger.\nIf you need to change the caching behavior per image, you can configure headers to set the Cache-Control header on the upstream image (e.g. /some-asset.jpg, not /_next/image itself).", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-26", "text": "There is no mechanism to invalidate the cache at this time, so its best to keep minimumCacheTTL low. Otherwise you may need to manually change the src prop or delete <distDir>/cache/images.\ndisableStaticImages\nThe default behavior allows you to import static files such as import icon from './icon.png and then pass that to the src property.\nIn some cases, you may wish to disable this feature if it conflicts with other plugins that expect the import to behave differently.\nYou can disable static image imports inside your next.config.js:\nnext.config.js module.exports = {\n  images: {\n    disableStaticImages: true,\n  },\n}\ndangerouslyAllowSVG", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-27", "text": "disableStaticImages: true,\n  },\n}\ndangerouslyAllowSVG\nThe default loader does not optimize SVG images for a few reasons. First, SVG is a vector format meaning it can be resized losslessly. Second, SVG has many of the same features as HTML/CSS, which can lead to vulnerabilities without proper Content Security Policy (CSP) headers.\nIf you need to serve SVG images with the default Image Optimization API, you can set dangerouslyAllowSVG inside your next.config.js:\nnext.config.js module.exports = {\n  images: {\n    dangerouslyAllowSVG: true,\n    contentDispositionType: 'attachment',\n    contentSecurityPolicy: \"default-src 'self'; script-src 'none'; sandbox;\",\n  },\n}\nIn addition, it is strongly recommended to also set contentDispositionType to force the browser to download the image, as well as contentSecurityPolicy to prevent scripts embedded in the image from executing.\nAnimated Images", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-28", "text": "Animated Images\nThe default loader will automatically bypass Image Optimization for animated images and serve the image as-is.\nAuto-detection for animated files is best-effort and supports GIF, APNG, and WebP. If you want to explicitly bypass Image Optimization for a given animated image, use the unoptimized prop.\nKnown Browser Bugs\nThis next/image component uses browser native lazy loading, which may fallback to eager loading for older browsers before Safari 15.4. When using the blur-up placeholder, older browsers before Safari 12 will fallback to empty placeholder. When using styles with width/height of auto, it is possible to cause Layout Shift on older browsers before Safari 15 that don't preserve the aspect ratio. For more details, see this MDN video.\nSafari 15 and 16 display a gray border while loading. Safari 16.4 fixed this issue. Possible solutions:", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-29", "text": "Use CSS @supports (font: -apple-system-body) and (-webkit-appearance: none) { img[loading=\"lazy\"] { clip-path: inset(0.6px) } }\nUse priority if the image is above the fold\nFirefox 67+ displays a white background while loading. Possible solutions:\nEnable AVIF formats\nUse placeholder=\"blur\"\nVersion History", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-30", "text": "VersionChangesv13.2.0contentDispositionType configuration added.v13.0.6ref prop added.v13.0.0The next/image import was renamed to next/legacy/image. The next/future/image import was renamed to next/image. A codemod is available to safely and automatically rename your imports. <span> wrapper removed. layout, objectFit, objectPosition, lazyBoundary, lazyRoot props removed. alt is required. onLoadingComplete receives reference to img element. Built-in loader config removed.v12.3.0remotePatterns and unoptimized configuration is stable.v12.2.0Experimental remotePatterns and experimental unoptimized configuration added. layout=\"raw\" removed.v12.1.1style prop added. Experimental support for layout=\"raw\" added.v12.1.0dangerouslyAllowSVG and contentSecurityPolicy configuration added.v12.0.9lazyRoot prop added.v12.0.0formats configuration added.AVIF support", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "0cbd170b2a92-31", "text": "prop added.v12.0.0formats configuration added.AVIF support added.Wrapper <div> changed to <span>.v11.1.0onLoadingComplete and lazyBoundary props added.v11.0.0src prop support for static import.placeholder prop added.blurDataURL prop added.v10.0.5loader prop added.v10.0.1layout prop added.v10.0.0next/image introduced.", "source": "https://nextjs.org/docs/app/api-reference/components/image"}
{"id": "4a4414b4536a-0", "text": "<Link>\nExamples\nHello World\nActive className on Link\n<Link> is a React component that extends the HTML <a> element to provide prefetching and client-side navigation between routes. It is the primary way to navigate between routes in Next.js.\napp/page.tsx import Link from 'next/link'\n \nexport default function Page() {\n  return <Link href=\"/dashboard\">Dashboard</Link>\n}\nProps\nHere's a summary of the props available for the Link Component:\nPropExampleTypeRequiredhrefhref=\"/dashboard\"String or ObjectYesreplacereplace={false}Boolean-prefetchprefetch={false}Boolean-\nGood to know: <a> tag attributes such as className or target=\"_blank\" can be added to <Link> as props and will be passed to the underlying <a> element.\nhref (required)\nThe path or URL to navigate to.\n <Link href=\"/dashboard\">Dashboard</Link>", "source": "https://nextjs.org/docs/app/api-reference/components/link"}
{"id": "4a4414b4536a-1", "text": "The path or URL to navigate to.\n <Link href=\"/dashboard\">Dashboard</Link>\nhref can also accept an object, for example:\n // Navigate to /about?name=test\n<Link\n  href={{\n    pathname: '/about',\n    query: { name: 'test' },\n  }}\n>\n  About\n</Link>\nreplace\nDefaults to false. When true, next/link will replace the current history state instead of adding a new URL into the browser\u2019s history stack.\napp/page.tsx import Link from 'next/link'\n \nexport default function Page() {\n  return (\n    <Link href=\"/dashboard\" replace>\n      Dashboard\n    </Link>\n  )\n}\nprefetch", "source": "https://nextjs.org/docs/app/api-reference/components/link"}
{"id": "4a4414b4536a-2", "text": "Dashboard\n    </Link>\n  )\n}\nprefetch\nDefaults to true. When true, next/link will prefetch the page (denoted by the href) in the background. This is useful for improving the performance of client-side navigations. Any <Link /> in the viewport (initially or through scroll) will be preloaded.\nPrefetch can be disabled by passing prefetch={false}. Prefetching is only enabled in production.\napp/page.tsx import Link from 'next/link'\n \nexport default function Page() {\n  return (\n    <Link href=\"/dashboard\" prefetch={false}>\n      Dashboard\n    </Link>\n  )\n}\nExamples\nLinking to Dynamic Routes\nFor dynamic routes, it can be handy to use template literals to create the link's path.", "source": "https://nextjs.org/docs/app/api-reference/components/link"}
{"id": "4a4414b4536a-3", "text": "For dynamic routes, it can be handy to use template literals to create the link's path.\nFor example, you can generate a list of links to the dynamic route app/blog/[slug]/page.js:app/blog/page.js import Link from 'next/link'\n \nfunction Page({ posts }) {\n  return (\n    <ul>\n      {posts.map((post) => (\n        <li key={post.id}>\n          <Link href={`/blog/${post.slug}`}>{post.title}</Link>\n        </li>\n      ))}\n    </ul>\n  )\n}\nMiddleware", "source": "https://nextjs.org/docs/app/api-reference/components/link"}
{"id": "4a4414b4536a-4", "text": "))}\n    </ul>\n  )\n}\nMiddleware\nIt's common to use Middleware for authentication or other purposes that involve rewriting the user to a different page. In order for the <Link /> component to properly prefetch links with rewrites via Middleware, you need to tell Next.js both the URL to display and the URL to prefetch. This is required to avoid un-necessary fetches to middleware to know the correct route to prefetch.\nFor example, if you want to serve a /dashboard route that has authenticated and visitor views, you may add something similar to the following in your Middleware to redirect the user to the correct page:\nmiddleware.js export function middleware(req) {\n  const nextUrl = req.nextUrl\n  if (nextUrl.pathname === '/dashboard') {\n    if (req.cookies.authToken) {\n      return NextResponse.rewrite(new URL('/auth/dashboard', req.url))\n    } else {", "source": "https://nextjs.org/docs/app/api-reference/components/link"}
{"id": "4a4414b4536a-5", "text": "} else {\n      return NextResponse.rewrite(new URL('/public/dashboard', req.url))\n    }\n  }\n}\nIn this case, you would want to use the following code in your <Link /> component:\n import Link from 'next/link'\nimport useIsAuthed from './hooks/useIsAuthed'\n \nexport default function Page() {\n  const isAuthed = useIsAuthed()\n  const path = isAuthed ? '/auth/dashboard' : '/dashboard'\n  return (\n    <Link as=\"/dashboard\" href={path}>\n      Dashboard\n    </Link>\n  )\n}\nVersion History", "source": "https://nextjs.org/docs/app/api-reference/components/link"}
{"id": "4a4414b4536a-6", "text": "Dashboard\n    </Link>\n  )\n}\nVersion History\nVersionChangesv13.0.0No longer requires a child <a> tag. A codemod is provided to automatically update your codebase.v10.0.0href props pointing to a dynamic route are automatically resolved and no longer require an as prop.v8.0.0Improved prefetching performance.v1.0.0next/link introduced.", "source": "https://nextjs.org/docs/app/api-reference/components/link"}
{"id": "c89b133466ca-0", "text": "<Script>\nThis API reference will help you understand how to use props available for the Script Component. For features and usage, please see the Optimizing Scripts page.\napp/dashboard/page.tsx import Script from 'next/script'\n \nexport default function Dashboard() {\n  return (\n    <>\n      <Script src=\"https://example.com/script.js\" />\n    </>\n  )\n}\nProps\nHere's a summary of the props available for the Script Component:\nPropExampleTypeRequiredsrcsrc=\"http://example.com/script\"StringRequired unless inline script is usedstrategystrategy=\"lazyOnload\"String-onLoadonLoad={onLoadFunc}Function-onReadyonReady={onReadyFunc}Function-onErroronError={onErrorFunc}Function-\nRequired Props\nThe <Script /> component requires the following properties.\nsrc", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-1", "text": "Required Props\nThe <Script /> component requires the following properties.\nsrc\nA path string specifying the URL of an external script. This can be either an absolute external URL or an internal path. The src property is required unless an inline script is used.\nOptional Props\nThe <Script /> component accepts a number of additional properties beyond those which are required.\nstrategy\nThe loading strategy of the script. There are four different strategies that can be used:\nbeforeInteractive: Load before any Next.js code and before any page hydration occurs.\nafterInteractive: (default) Load early but after some hydration on the page occurs.\nlazyOnload: Load during browser idle time.\nworker: (experimental) Load in a web worker.\nbeforeInteractive\nScripts that load with the beforeInteractive strategy are injected into the initial HTML from the server, downloaded before any Next.js module, and executed in the order they are placed before any hydration occurs on the page.", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-2", "text": "Scripts denoted with this strategy are preloaded and fetched before any first-party code, but their execution does not block page hydration from occurring.\nbeforeInteractive scripts must be placed inside the root layout (app/layout.tsx) and are designed to load scripts that are needed by the entire site (i.e. the script will load when any page in the application has been loaded server-side).\nThis strategy should only be used for critical scripts that need to be fetched before any part of the page becomes interactive.\napp/layout.tsx import Script from 'next/script'\n \nexport default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n      <Script\n        src=\"https://example.com/script.js\"\n        strategy=\"beforeInteractive\"\n      />\n    </html>\n  )\n}", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-3", "text": "strategy=\"beforeInteractive\"\n      />\n    </html>\n  )\n}\nGood to know: Scripts with beforeInteractive will always be injected inside the head of the HTML document regardless of where it's placed in the component.\nSome examples of scripts that should be loaded as soon as possible with beforeInteractive include:\nBot detectors\nCookie consent managers\nafterInteractive\nScripts that use the afterInteractive strategy are injected into the HTML client-side and will load after some (or all) hydration occurs on the page. This is the default strategy of the Script component and should be used for any script that needs to load as soon as possible but not before any first-party Next.js code.\nafterInteractive scripts can be placed inside of any page or layout and will only load and execute when that page (or group of pages) is opened in the browser.\napp/page.js import Script from 'next/script'\n \nexport default function Page() {\n  return (", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-4", "text": "export default function Page() {\n  return (\n    <>\n      <Script src=\"https://example.com/script.js\" strategy=\"afterInteractive\" />\n    </>\n  )\n}\nSome examples of scripts that are good candidates for afterInteractive include:\nTag managers\nAnalytics\nlazyOnload\nScripts that use the lazyOnload strategy are injected into the HTML client-side during browser idle time and will load after all resources on the page have been fetched. This strategy should be used for any background or low priority scripts that do not need to load early.\nlazyOnload scripts can be placed inside of any page or layout and will only load and execute when that page (or group of pages) is opened in the browser.\napp/page.js import Script from 'next/script'\n \nexport default function Page() {\n  return (\n    <>", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-5", "text": "export default function Page() {\n  return (\n    <>\n      <Script src=\"https://example.com/script.js\" strategy=\"lazyOnload\" />\n    </>\n  )\n}\nExamples of scripts that do not need to load immediately and can be fetched with lazyOnload include:\nChat support plugins\nSocial media widgets\nworker\nWarning: The worker strategy is not yet stable and does not yet work with the app directory. Use with caution.\nScripts that use the worker strategy are off-loaded to a web worker in order to free up the main thread and ensure that only critical, first-party resources are processed on it. While this strategy can be used for any script, it is an advanced use case that is not guaranteed to support all third-party scripts.\nTo use worker as a strategy, the nextScriptWorkers flag must be enabled in next.config.js:\nnext.config.js module.exports = {\n  experimental: {", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-6", "text": "next.config.js module.exports = {\n  experimental: {\n    nextScriptWorkers: true,\n  },\n}\nworker scripts can only currently be used in the pages/ directory:\npages/home.tsx import Script from 'next/script'\n \nexport default function Home() {\n  return (\n    <>\n      <Script src=\"https://example.com/script.js\" strategy=\"worker\" />\n    </>\n  )\n}\nonLoad\nWarning: onLoad does not yet work with Server Components and can only be used in Client Components. Further, onLoad can't be used with beforeInteractive \u2013 consider using onReady instead.\nSome third-party scripts require users to run JavaScript code once after the script has finished loading in order to instantiate content or call a function. If you are loading a script with either afterInteractive or lazyOnload as a loading strategy, you can execute code after it has loaded using the onLoad property.", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-7", "text": "Here's an example of executing a lodash method only after the library has been loaded.\napp/page.tsx 'use client'\n \nimport Script from 'next/script'\n \nexport default function Page() {\n  return (\n    <>\n      <Script\n        src=\"https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js\"\n        onLoad={() => {\n          console.log(_.sample([1, 2, 3, 4]))\n        }}\n      />\n    </>\n  )\n}\nonReady\nWarning: onReady does not yet work with Server Components and can only be used in Client Components.", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-8", "text": "Some third-party scripts require users to run JavaScript code after the script has finished loading and every time the component is mounted (after a route navigation for example). You can execute code after the script's load event when it first loads and then after every subsequent component re-mount using the onReady property.\nHere's an example of how to re-instantiate a Google Maps JS embed every time the component is mounted:\napp/page.tsx 'use client'\n \nimport { useRef } from 'react'\nimport Script from 'next/script'\n \nexport default function Page() {\n  const mapRef = useRef()\n \n  return (\n    <>\n      <div ref={mapRef}></div>\n      <Script\n        id=\"google-maps\"\n        src=\"https://maps.googleapis.com/maps/api/js\"\n        onReady={() => {\n          new google.maps.Map(mapRef.current, {", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-9", "text": "onReady={() => {\n          new google.maps.Map(mapRef.current, {\n            center: { lat: -34.397, lng: 150.644 },\n            zoom: 8,\n          })\n        }}\n      />\n    </>\n  )\n}\nonError\nWarning: onError does not yet work with Server Components and can only be used in Client Components. onError cannot be used with the beforeInteractive loading strategy.\nSometimes it is helpful to catch when a script fails to load. These errors can be handled with the onError property:\napp/page.tsx 'use client'\n \nimport Script from 'next/script'\n \nexport default function Page() {\n  return (\n    <>\n      <Script\n        src=\"https://example.com/script.js\"\n        onError={(e: Error) => {\n          console.error('Script failed to load', e)\n        }}\n      />", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "c89b133466ca-10", "text": "console.error('Script failed to load', e)\n        }}\n      />\n    </>\n  )\n}\nVersion History\nVersionChangesv13.0.0beforeInteractive and afterInteractive is modified to support app.v12.2.4onReady prop added.v12.2.2Allow next/script with beforeInteractive to be placed in _document.v11.0.0next/script introduced.", "source": "https://nextjs.org/docs/app/api-reference/components/script"}
{"id": "df1f2617208f-0", "text": "default.jsThis documentation is still being written. Please check back later.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/default"}
{"id": "d748f53ee440-0", "text": "error.jsAn error file defines an error UI boundary for a route segment.\nIt is useful for catching unexpected errors that occur in Server Components and Client Components and displaying a fallback UI.\napp/dashboard/error.tsx 'use client' // Error components must be Client Components\n \nimport { useEffect } from 'react'\n \nexport default function Error({\n  error,\n  reset,\n}: {\n  error: Error & { digest?: string }\n  reset: () => void\n}) {\n  useEffect(() => {\n    // Log the error to an error reporting service\n    console.error(error)\n  }, [error])\n \n  return (\n    <div>\n      <h2>Something went wrong!</h2>\n      <button\n        onClick={\n          // Attempt to recover by trying to re-render the segment\n          () => reset()\n        }\n      >\n        Try again\n      </button>", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/error"}
{"id": "d748f53ee440-1", "text": "}\n      >\n        Try again\n      </button>\n    </div>\n  )\n}\nProps\nerror\nAn instance of an Error object forwarded to the error.js Client Component.\nerror.message\nThe error message.\nFor errors forwarded from Client Components, this will be the original Error's message.\nFor errors forwarded from Server Components, this will be a generic error message to avoid leaking sensitive details. errors.digest can be used to match the corresponding error in server-side logs.\nerror.digest\nAn automatically generated hash of the error thrown in a Server Component. It can be used to match the corresponding error in server-side logs.\nreset\nA function to reset the error boundary. When executed, the function will try to re-render the Error boundary's contents. If successful, the fallback error component is replaced with the result of the re-render.\nCan be used to prompt the user to attempt to recover from the error.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/error"}
{"id": "d748f53ee440-2", "text": "Can be used to prompt the user to attempt to recover from the error.\nGood to know:\nerror.js boundaries must be Client Components.\nIn Production builds, errors forwarded from Server Components will be stripped of specific error details to avoid leaking sensitive information.\nAn error.js boundary will not handle errors thrown in a layout.js component in the same segment because the error boundary is nested inside that layouts component.\nTo handle errors for a specific layout, place an error.js file in the layouts parent segment.\nTo handle errors within the root layout or template, use a variation of error.js called app/global-error.js.\nglobal-error.js\nTo specifically handle errors in root layout.js, use a variation of error.js called app/global-error.js located in the root app directory.\napp/global-error.tsx 'use client'\n \nexport default function GlobalError({\n  error,\n  reset,\n}: {\n  error: Error & { digest?: string }", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/error"}
{"id": "d748f53ee440-3", "text": "reset,\n}: {\n  error: Error & { digest?: string }\n  reset: () => void\n}) {\n  return (\n    <html>\n      <body>\n        <h2>Something went wrong!</h2>\n        <button onClick={() => reset()}>Try again</button>\n      </body>\n    </html>\n  )\n}\nGood to know:\nglobal-error.js replaces the root layout.js when active and so must define its own <html> and <body> tags.\nWhile designing error UI, you may find it helpful to use the React Developer Tools to manually toggle Error boundaries.\nVersion History\nVersionChangesv13.1.0global-error introduced.v13.0.0error introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/error"}
{"id": "dee6154bd3c1-0", "text": "layout.jsA layout is UI that is shared between routes.\napp/dashboard/layout.tsx export default function DashboardLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return <section>{children}</section>\n}\nA root layout is the top-most layout in the root app directory. It is used to define the <html> and <body> tags and other globally shared UI.\napp/layout.tsx export default function RootLayout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n    </html>\n  )\n}\nProps\nchildren (required)", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/layout"}
{"id": "dee6154bd3c1-1", "text": "</html>\n  )\n}\nProps\nchildren (required)\nLayout components should accept and use a children prop. During rendering, children will be populated with the route segments the layout is wrapping. These will primarily be the component of a child Layout (if it exists) or Page, but could also be other special files like Loading or Error when applicable.\nparams (optional)\nThe dynamic route parameters object from the root segment down to that layout.\nExampleURLparamsapp/dashboard/[team]/layout.js/dashboard/1{ team: '1' }app/shop/[tag]/[item]/layout.js/shop/1/2{ tag: '1', item: '2' }app/blog/[...slug]/layout.js/blog/1/2{ slug: ['1', '2'] }\nFor example:\napp/shop/[tag]/[item]/layout.tsx export default function ShopLayout({\n  children,\n  params,\n}: {", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/layout"}
{"id": "dee6154bd3c1-2", "text": "children,\n  params,\n}: {\n  children: React.ReactNode\n  params: {\n    tag: string\n    item: string\n  }\n}) {\n  // URL -> /shop/shoes/nike-air-max-97\n  // `params` -> { tag: 'shoes', item: 'nike-air-max-97' }\n  return <section>{children}</section>\n}\nGood to know\nLayout's do not receive searchParams\nUnlike Pages, Layout components do not receive the searchParams prop. This is because a shared layout is not re-rendered during navigation which could lead to stale searchParams between navigations.\nWhen using client-side navigation, Next.js automatically only renders the part of the page below the common layout between two routes.\nFor example, in the following directory structure, dashboard/layout.tsx is the common layout for both /dashboard/settings and /dashboard/analytics:\n app", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/layout"}
{"id": "dee6154bd3c1-3", "text": "app\n\u2514\u2500\u2500 dashboard\n    \u251c\u2500\u2500 layout.tsx\n    \u251c\u2500\u2500 settings\n    \u2502   \u2514\u2500\u2500 page.tsx\n    \u2514\u2500\u2500 analytics\n        \u2514\u2500\u2500 page.js\nWhen navigating from /dashboard/settings to /dashboard/analytics, page.tsx in /dashboard/analytics will be rendered on the server because it is UI that changed, while dashboard/layout.tsx will not be re-rendered because it is a common UI between the two routes.\nThis performance optimization allows navigation between pages that share a layout to be quicker as only the data fetching and rendering for the page has to run, instead of the entire route that could include shared layouts that fetch their own data.\nBecause dashboard/layout.tsx doesn't re-render, the searchParams prop in the layout Server Component might become stale after navigation.\nInstead, use the Page searchParams prop or the useSearchParams hook in a Client Component, which is re-rendered on the client with the latest searchParams.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/layout"}
{"id": "dee6154bd3c1-4", "text": "Root Layouts\nThe app directory must include a root app/layout.js.\nThe root layout must define <html> and <body> tags.\nYou should not manually add <head> tags such as <title> and <meta> to root layouts. Instead, you should use the Metadata API which automatically handles advanced requirements such as streaming and de-duplicating <head> elements.\nYou can use route groups to create multiple root layouts.\nNavigating across multiple root layouts will cause a full page load (as opposed to a client-side navigation). For example, navigating from /cart that uses app/(shop)/layout.js to /blog that uses app/(marketing)/layout.js will cause a full page load. This only applies to multiple root layouts.\nVersion History\nVersionChangesv13.0.0layout introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/layout"}
{"id": "2e4729537772-0", "text": "loading.jsA loading file can create instant loading states built on Suspense.\nBy default, this file is a Server Component - but can also be used as a Client Component through the \"use client\" directive.\napp/feed/loading.tsx export default function Loading() {\n  // Or a custom loading skeleton component\n  return <p>'Loading...'</p>\n}\nLoading UI components do not accept any parameters.\nGood to know\nWhile designing loading UI, you may find it helpful to use the React Developer Tools to manually toggle Suspense boundaries.\nVersion History\nVersionChangesv13.0.0loading introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/loading"}
{"id": "b781d741d3fc-0", "text": "not-found.jsThe not-found file is used to render UI when the notFound function is thrown within a route segment. Along with serving a custom UI, Next.js will also return a 404 HTTP status code.\napp/blog/not-found.tsx import Link from 'next/link'\n \nexport default function NotFound() {\n  return (\n    <div>\n      <h2>Not Found</h2>\n      <p>Could not find requested resource</p>\n      <p>\n        View <Link href=\"/blog\">all posts</Link>\n      </p>\n    </div>\n  )\n}\nGood to know: In addition to catching expected notFound() errors, the root app/not-found.js file also handles any unmatched URLs for your whole application. This means users that visit a URL that is not handled by your app will be shown the UI exported by the app/not-found.js file.\nProps", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/not-found"}
{"id": "b781d741d3fc-1", "text": "Props\nnot-found.js components do not accept any props.\nVersion History\nVersionChangesv13.3.0Root app/not-found handles global unmatched URLs.v13.0.0not-found introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/not-found"}
{"id": "60aeb2307567-0", "text": "page.jsA page is UI that is unique to a route.\napp/blog/[slug]/page.tsx export default function Page({\n  params,\n  searchParams,\n}: {\n  params: { slug: string }\n  searchParams: { [key: string]: string | string[] | undefined }\n}) {\n  return <h1>My Page</h1>\n}\nProps\nparams (optional)\nAn object containing the dynamic route parameters from the root segment down to that page. For example:\nExampleURLparamsapp/shop/[slug]/page.js/shop/1{ slug: '1' }app/shop/[category]/[item]/page.js/shop/1/2{ category: '1', item: '2' }app/shop/[...slug]/page.js/shop/1/2{ slug: ['1', '2'] }\nsearchParams (optional)", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/page"}
{"id": "60aeb2307567-1", "text": "searchParams (optional)\nAn object containing the search parameters of the current URL. For example:\nURLsearchParams/shop?a=1{ a: '1' }/shop?a=1&b=2{ a: '1', b: '2' }/shop?a=1&a=2{ a: ['1', '2'] }\nGood to know:\nsearchParams is a Dynamic API whose values cannot be known ahead of time. Using it will opt the page into dynamic rendering at request time.\nsearchParams returns a plain JavaScript object and not a URLSearchParams instance.\nVersion History\nVersionChangesv13.0.0page introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/page"}
{"id": "fbec914e01ed-0", "text": "route.jsRoute Handlers allow you to create custom request handlers for a given route using the Web Request and Response APIs.\nHTTP Methods\nA route file allows you to create custom request handlers for a given route. The following HTTP methods are supported: GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS.\nroute.ts export async function GET(request: Request) {}\n \nexport async function HEAD(request: Request) {}\n \nexport async function POST(request: Request) {}\n \nexport async function PUT(request: Request) {}\n \nexport async function DELETE(request: Request) {}\n \nexport async function PATCH(request: Request) {}\n \n// If `OPTIONS` is not defined, Next.js will automatically implement `OPTIONS` and  set the appropriate Response `Allow` header depending on the other methods defined in the route handler.\nexport async function OPTIONS(request: Request) {}", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route"}
{"id": "fbec914e01ed-1", "text": "export async function OPTIONS(request: Request) {}\nGood to know: Route Handlers are only available inside the app directory. You do not need to use API Routes (pages) and Route Handlers (app) together, as Route Handlers should be able to handle all use cases.\nParameters\nrequest (optional)\nThe request object is a NextRequest object, which is an extension of the Web Request API. NextRequest gives you further control over the incoming request, including easily accessing cookies and an extended, parsed, URL object nextUrl.\ncontext (optional)\napp/dashboard/[team]/route.js export async function GET(request, context: { params }) {\n  const team = params.team // '1'\n}\nCurrently, the only value of context is params, which is an object containing the dynamic route parameters for the current route.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route"}
{"id": "fbec914e01ed-2", "text": "ExampleURLparamsapp/dashboard/[team]/route.js/dashboard/1{ team: '1' }app/shop/[tag]/[item]/route.js/shop/1/2{ tag: '1', item: '2' }app/blog/[...slug]/route.js/blog/1/2{ slug: ['1', '2'] }\nNextResponse\nRoute Handlers can extend the Web Response API by returning a NextResponse object. This allows you to easily set cookies, headers, redirect, and rewrite. View the API reference.\nVersion History\nVersionChangesv13.2.0Route handlers are introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route"}
{"id": "f7873f4ee4f9-0", "text": "Route Segment ConfigThe Route Segment options allows you configure the behavior of a Page, Layout, or Route Handler by directly exporting the following variables:\nOptionTypeDefaultdynamic'auto' | 'force-dynamic' | 'error' | 'force-static''auto'dynamicParamsbooleantruerevalidatefalse | 'force-cache' | 0 | numberfalsefetchCache'auto' | 'default-cache' | 'only-cache' | 'force-cache' | 'force-no-store' | 'default-no-store' | 'only-no-store''auto'runtime'nodejs' | 'edge''nodejs'preferredRegion'auto' | 'global' | 'home' | string | string[]'auto'maxDurationnumberSet by deployment platform\nlayout.tsx / page.tsx / route.ts export const dynamic = 'auto'\nexport const dynamicParams = true\nexport const revalidate = false\nexport const fetchCache = 'auto'", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-1", "text": "export const revalidate = false\nexport const fetchCache = 'auto'\nexport const runtime = 'nodejs'\nexport const preferredRegion = 'auto'\nexport const maxDuration = 5\n \nexport default function MyComponent() {}\nGood to know:\nThe values of the config options currently need be statically analyzable. For example revalidate = 600 is valid, but revalidate = 60 * 10 is not.\nOptions\ndynamic\nChange the dynamic behavior of a layout or page to fully static or fully dynamic.\nlayout.tsx / page.tsx / route.ts export const dynamic = 'auto'\n// 'auto' | 'force-dynamic' | 'error' | 'force-static'", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-2", "text": "// 'auto' | 'force-dynamic' | 'error' | 'force-static'\nGood to know: The new model in the app directory favors granular caching control at the fetch request level over the binary all-or-nothing model of getServerSideProps and getStaticProps at the page-level in the pages directory. The dynamic option is a way to opt back in to the previous model as a convenience and provides a simpler migration path.\n'auto' (default): The default option to cache as much as possible without preventing any components from opting into dynamic behavior.\n'force-dynamic': Force dynamic rendering and dynamic data fetching of a layout or page by disabling all caching of fetch requests and always revalidating. This option is equivalent to:\ngetServerSideProps() in the pages directory.\nSetting the option of every fetch() request in a layout or page to { cache: 'no-store', next: { revalidate: 0 } }.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-3", "text": "Setting the segment config to export const fetchCache = 'force-no-store'\n'error': Force static rendering and static data fetching of a layout or page by causing an error if any components use dynamic functions or dynamic fetches. This option is equivalent to:\ngetStaticProps() in the pages directory.\nSetting the option of every fetch() request in a layout or page to { cache: 'force-cache' }.\nSetting the segment config to fetchCache = 'only-cache', dynamicParams = false.\ndynamic = 'error' changes the default of dynamicParams from true to false. You can opt back into dynamically rendering pages for dynamic params not generated by generateStaticParams by manually setting dynamicParams = true.\n'force-static': Force static rendering and static data fetching of a layout or page by forcing cookies(), headers() and useSearchParams() to return empty values.\nGood to know:", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-4", "text": "Good to know:\nInstructions on how to migrate from getServerSideProps and getStaticProps to dynamic: 'force-dynamic' and dynamic: 'error' can be found in the upgrade guide.\ndynamicParams\nControl what happens when a dynamic segment is visited that was not generated with generateStaticParams.\nlayout.tsx / page.tsx export const dynamicParams = true // true | false,\ntrue (default): Dynamic segments not included in generateStaticParams are generated on demand.\nfalse: Dynamic segments not included in generateStaticParams will return a 404.\nGood to know:\nThis option replaces the fallback: true | false | blocking option of getStaticPaths in the pages directory.\nWhen dynamicParams = true, the segment uses Streaming Server Rendering.\nIf the dynamic = 'error' and dynamic = 'force-static' are used, it'll change the default of dynamicParams to false.\nrevalidate", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-5", "text": "revalidate\nSet the default revalidation time for a layout or page. This option does not override the revalidate value set by individual fetch requests.\nlayout.tsx / page.tsx / route.ts export const revalidate = false\n// false | 'force-cache' | 0 | number\nfalse: (default) The default heuristic to cache any fetch requests that set their cache option to 'force-cache' or are discovered before a dynamic function is used. Semantically equivalent to revalidate: Infinity which effectively means the resource should be cached indefinitely. It is still possible for individual fetch requests to use cache: 'no-store' or revalidate: 0 to avoid being cached and make the route dynamically rendered. Or set revalidate to a positive number lower than the route default to increase the revalidation frequency of a route.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-6", "text": "0: Ensure a layout or page is always dynamically rendered even if no dynamic functions or dynamic data fetches are discovered. This option changes the default of fetch requests that do not set a cache option to 'no-store' but leaves fetch requests that opt into 'force-cache' or use a positive revalidate as is.\nnumber: (in seconds) Set the default revalidation frequency of a layout or page to n seconds.\nRevalidation Frequency\nThe lowest revalidate across each layout and page of a single route will determine the revalidation frequency of the entire route. This ensures that child pages are revalidated as frequently as their parent layouts.\nIndividual fetch requests can set a lower revalidate than the route's default revalidate to increase the revalidation frequency of the entire route. This allows you to dynamically opt-in to more frequent revalidation for certain routes based on some criteria.\nfetchCache", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-7", "text": "fetchCache\nThis is an advanced option that should only be used if you specifically need to override the default behavior.By default, Next.js will cache any fetch() requests that are reachable before any dynamic functions are used and will not cache fetch requests that are discovered after dynamic functions are used.fetchCache allows you to override the default cache option of all fetch requests in a layout or page.layout.tsx / page.tsx / route.ts export const fetchCache = 'auto'\n// 'auto' | 'default-cache' | 'only-cache'\n// 'force-cache' | 'force-no-store' | 'default-no-store' | 'only-no-store'\n'auto' (default)- The default option to cache fetch requests before dynamic functions with the cache option they provide and not cache fetch requests after dynamic functions.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-8", "text": "'default-cache': Allow any cache option to be passed to fetch but if no option is provided then set the cache option to 'force-cache'. This means that even fetch requests after dynamic functions are considered static.\n'only-cache': Ensure all fetch requests opt into caching by changing the default to cache: 'force-cache' if no option is provided and causing an error if any fetch requests use cache: 'no-store'.\n'force-cache': Ensure all fetch requests opt into caching by setting the cache option of all fetch requests to 'force-cache'.\n'default-no-store': Allow any cache option to be passed to fetch but if no option is provided then set the cache option to 'no-store'. This means that even fetch requests before dynamic functions are considered dynamic.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-9", "text": "'only-no-store': Ensure all fetch requests opt out of caching by changing the default to cache: 'no-store' if no option is provided and causing an error if any fetch requests use cache: 'force-cache'\n'force-no-store': Ensure all fetch requests opt out of caching by setting the cache option of all fetch requests to 'no-store'. This forces all fetch requests to be re-fetched every request even if they provide a 'force-cache' option.\nCross-route segment behavior\nAny options set across each layout and page of a single route need to be compatible with each other.\nIf both the 'only-cache' and 'force-cache' are provided, then 'force-cache' wins. If both 'only-no-store' and 'force-no-store' are provided, then 'force-no-store' wins. The force option changes the behavior across the route so a single segment with 'force-*' would prevent any errors caused by 'only-*'.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-10", "text": "The intention of the 'only-*' and force-*' options is to guarantee the whole route is either fully static or fully dynamic. This means:\nA combination of 'only-cache' and 'only-no-store' in a single route is not allowed.\nA combination of 'force-cache' and 'force-no-store' in a single route is not allowed.\nA parent cannot provide 'default-no-store' if a child provides 'auto' or '*-cache' since that could make the same fetch have different behavior.\nIt is generally recommended to leave shared parent layouts as 'auto' and customize the options where child segments diverge.\nruntime\nlayout.tsx / page.tsx / route.ts export const runtime = 'nodejs'\n// 'edge' | 'nodejs'\nnodejs (default)\nedge\nLearn more about the Edge and Node.js runtimes.\npreferredRegion", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-11", "text": "edge\nLearn more about the Edge and Node.js runtimes.\npreferredRegion\nlayout.tsx / page.tsx / route.ts export const preferredRegion = 'auto'\n// 'auto' | 'global' | 'home' | ['iad1', 'sfo1']\nSupport for preferredRegion, and regions supported, is dependent on your deployment platform.\nGood to know:\nIf a preferredRegion is not specified, it will inherit the option of the nearest parent layout.\nThe root layout defaults to all regions.\nmaxDuration\nBased on your deployment platform, you may be able to use a higher default execution time for your function.\nThis setting allows you to opt into a higher execution time within your plans limit.\nNote: This settings requires Next.js 13.4.10 or higher.\nlayout.tsx / page.tsx / route.ts export const maxDuration = 5\nGood to know:", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "f7873f4ee4f9-12", "text": "Good to know:\nIf a maxDuration is not specified, the default value is dependent on your deployment platform and plan.\ngenerateStaticParams\nThe generateStaticParams function can be used in combination with dynamic route segments to define the list of route segment parameters that will be statically generated at build time instead of on-demand at request time.\nSee the API reference for more details.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config"}
{"id": "dc9430bb61da-0", "text": "template.jsThis documentation is still being written. Please check back later.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/template"}
{"id": "84146131d15b-0", "text": "favicon, icon, and apple-iconThe favicon, icon, or apple-icon file conventions allow you to set icons for your application.\nThey are useful for adding app icons that appear in places like web browser tabs, phone home screens, and search engine results.\nThere are two ways to set app icons:\nUsing image files (.ico, .jpg, .png)\nUsing code to generate an icon (.js, .ts, .tsx)\nImage files (.ico, .jpg, .png)\nUse an image file to set an app icon by placing a favicon, icon, or apple-icon image file within your /app directory.\nThe favicon image can only be located in the top level of app/.\nNext.js will evaluate the file and automatically add the appropriate tags to your app's <head> element.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-1", "text": "File conventionSupported file typesValid locationsfavicon.icoapp/icon.ico, .jpg, .jpeg, .png, .svgapp/**/*apple-icon.jpg, .jpeg, .pngapp/**/*\nfavicon\nAdd a favicon.ico image file to the root /app route segment.\n<head> output <link rel=\"icon\" href=\"/favicon.ico\" sizes=\"any\" />\nicon\nAdd an icon.(ico|jpg|jpeg|png|svg) image file.\n<head> output <link\n  rel=\"icon\"\n  href=\"/icon?<generated>\"\n  type=\"image/<generated>\"\n  sizes=\"<generated>\"\n/>\napple-icon\nAdd an apple-icon.(jpg|jpeg|png) image file.\n<head> output <link\n  rel=\"apple-touch-icon\"\n  href=\"/apple-icon?<generated>\"\n  type=\"image/<generated>\"\n  sizes=\"<generated>\"\n/>\nGood to know", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-2", "text": "type=\"image/<generated>\"\n  sizes=\"<generated>\"\n/>\nGood to know\nYou can set multiple icons by adding a number suffix to the file name. For example, icon1.png, icon2.png, etc. Numbered files will sort lexically.\nFavicons can only be set in the root /app segment. If you need more granularity, you can use icon.\nThe appropriate <link> tags and attributes such as rel, href, type, and sizes are determined by the icon type and metadata of the evaluated file.\nFor example, a 32 by 32px .png file will have type=\"image/png\" and sizes=\"32x32\" attributes.\nsizes=\"any\" is added to favicon.ico output to avoid a browser bug where an .ico icon is favored over .svg.\nGenerate icons using code (.js, .ts, .tsx)", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-3", "text": "Generate icons using code (.js, .ts, .tsx)\nIn addition to using literal image files, you can programmatically generate icons using code.\nGenerate an app icon by creating an icon or apple-icon route that default exports a function.\nFile conventionSupported file typesicon.js, .ts, .tsxapple-icon.js, .ts, .tsx\nThe easiest way to generate an icon is to use the ImageResponse API from next/server.\napp/icon.tsx import { ImageResponse } from 'next/server'\n \n// Route segment config\nexport const runtime = 'edge'\n \n// Image metadata\nexport const size = {\n  width: 32,\n  height: 32,\n}\nexport const contentType = 'image/png'\n \n// Image generation\nexport default function Icon() {\n  return new ImageResponse(\n    (\n      // ImageResponse JSX element\n      <div\n        style={{", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-4", "text": "(\n      // ImageResponse JSX element\n      <div\n        style={{\n          fontSize: 24,\n          background: 'black',\n          width: '100%',\n          height: '100%',\n          display: 'flex',\n          alignItems: 'center',\n          justifyContent: 'center',\n          color: 'white',\n        }}\n      >\n        A\n      </div>\n    ),\n    // ImageResponse options\n    {\n      // For convenience, we can re-use the exported icons size metadata\n      // config to also set the ImageResponse's width and height.\n      ...size,\n    }\n  )\n}\n<head> output <link rel=\"icon\" href=\"/icon?<generated>\" type=\"image/png\" sizes=\"32x32\" />\nGood to know", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-5", "text": "Good to know\nBy default, generated icons are statically optimized (generated at build time and cached) unless they use dynamic functions or dynamic data fetching.\nYou can generate multiple icons in the same file using generateImageMetadata.\nYou cannot generate a favicon icon. Use icon or a favicon.ico file instead.\nProps\nThe default export function receives the following props:\nparams (optional)\nAn object containing the dynamic route parameters object from the root segment down to the segment icon or apple-icon is colocated in.\napp/shop/[slug]/icon.tsx export default function Icon({ params }: { params: { slug: string } }) {\n  // ...\n}", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-6", "text": "// ...\n}\nRouteURLparamsapp/shop/icon.js/shopundefinedapp/shop/[slug]/icon.js/shop/1{ slug: '1' }app/shop/[tag]/[item]/icon.js/shop/1/2{ tag: '1', item: '2' }app/shop/[...slug]/icon.js/shop/1/2{ slug: ['1', '2'] }\nReturns\nThe default export function should return a Blob | ArrayBuffer | TypedArray | DataView | ReadableStream | Response.\nGood to know: ImageResponse satisfies this return type.\nConfig exports\nYou can optionally configure the icon's metadata by exporting size and contentType variables from the icon or apple-icon route.\nOptionTypesize{ width: number; height: number }contentTypestring - image MIME type\nsize\nicon.tsx / apple-icon.tsx export const size = { width: 32, height: 32 }\n \nexport default function Icon() {}", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-7", "text": "export default function Icon() {}\n<head> output <link rel=\"icon\" sizes=\"32x32\" />\ncontentType\nicon.tsx / apple-icon.tsx export const contentType = 'image/png'\n \nexport default function Icon() {}\n<head> output <link rel=\"icon\" type=\"image/png\" />\nRoute Segment Config\nicon and apple-icon are specialized Route Handlers that can use the same route segment configuration options as Pages and Layouts.\nOptionTypeDefaultdynamic'auto' | 'force-dynamic' | 'error' | 'force-static''auto'revalidatefalse | 'force-cache' | 0 | numberfalseruntime'nodejs' | 'edge''nodejs'preferredRegion'auto' | 'global' | 'home' | string | string[]'auto'\napp/icon.tsx export const runtime = 'edge'\n \nexport default function Icon() {}\nVersion History", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "84146131d15b-8", "text": "export default function Icon() {}\nVersion History\nVersionChangesv13.3.0favicon icon and apple-icon introduced", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/app-icons"}
{"id": "bcfd80d6f30f-0", "text": "opengraph-image and twitter-imageThe opengraph-image and twitter-image file conventions allow you to set Open Graph and Twitter images for a route segment.\nThey are useful for setting the images that appear on social networks and messaging apps when a user shares a link to your site.\nThere are two ways to set Open Graph and Twitter images:\nUsing image files (.jpg, .png, .gif)\nUsing code to generate images (.js, .ts, .tsx)\nImage files (.jpg, .png, .gif)\nUse an image file to set a route segment's shared image by placing an opengraph-image or twitter-image image file in the segment.\nNext.js will evaluate the file and automatically add the appropriate tags to your app's <head> element.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-1", "text": "File conventionSupported file typesopengraph-image.jpg, .jpeg, .png, .giftwitter-image.jpg, .jpeg, .png, .gifopengraph-image.alt.txttwitter-image.alt.txt\nopengraph-image\nAdd an opengraph-image.(jpg|jpeg|png|gif) image file to any route segment.\n<head> output <meta property=\"og:image\" content=\"<generated>\" />\n<meta property=\"og:image:type\" content=\"<generated>\" />\n<meta property=\"og:image:width\" content=\"<generated>\" />\n<meta property=\"og:image:height\" content=\"<generated>\" />\ntwitter-image\nAdd a twitter-image.(jpg|jpeg|png|gif) image file to any route segment.\n<head> output <meta name=\"twitter:image\" content=\"<generated>\" />\n<meta name=\"twitter:image:type\" content=\"<generated>\" />\n<meta name=\"twitter:image:width\" content=\"<generated>\" />", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-2", "text": "<meta name=\"twitter:image:width\" content=\"<generated>\" />\n<meta name=\"twitter:image:height\" content=\"<generated>\" />\nopengraph-image.alt.txt\nAdd an accompanying opengraph-image.alt.txt file in the same route segment as the opengraph-image.(jpg|jpeg|png|gif) image it's alt text.\nopengraph-image.alt.txt About Acme\n<head> output <meta property=\"og:image:alt\" content=\"About Acme\" />\ntwitter-image.alt.txt\nAdd an accompanying twitter-image.alt.txt file in the same route segment as the twitter-image.(jpg|jpeg|png|gif) image it's alt text.\ntwitter-image.alt.txt About Acme\n<head> output <meta property=\"og:image:alt\" content=\"About Acme\" />\nGenerate images using code (.js, .ts, .tsx)\nIn addition to using literal image files, you can programmatically generate images using code.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-3", "text": "In addition to using literal image files, you can programmatically generate images using code.\nGenerate a route segment's shared image by creating an opengraph-image or twitter-image route that default exports a function.\nFile conventionSupported file typesopengraph-image.js, .ts, .tsxtwitter-image.js, .ts, .tsx\nGood to know\nBy default, generated images are statically optimized (generated at build time and cached) unless they use dynamic functions or dynamic data fetching.\nYou can generate multiple Images in the same file using generateImageMetadata.\nThe easiest way to generate an image is to use the ImageResponse API from next/server.\napp/about/opengraph-image.tsx import { ImageResponse } from 'next/server'\n \n// Route segment config\nexport const runtime = 'edge'\n \n// Image metadata\nexport const alt = 'About Acme'\nexport const size = {\n  width: 1200,", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-4", "text": "export const size = {\n  width: 1200,\n  height: 630,\n}\n \nexport const contentType = 'image/png'\n \n// Font\nconst interSemiBold = fetch(\n  new URL('./Inter-SemiBold.ttf', import.meta.url)\n).then((res) => res.arrayBuffer())\n \n// Image generation\nexport default async function Image() {\n  return new ImageResponse(\n    (\n      // ImageResponse JSX element\n      <div\n        style={{\n          fontSize: 128,\n          background: 'white',\n          width: '100%',\n          height: '100%',\n          display: 'flex',\n          alignItems: 'center',\n          justifyContent: 'center',\n        }}\n      >\n        About Acme\n      </div>\n    ),\n    // ImageResponse options\n    {", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-5", "text": "</div>\n    ),\n    // ImageResponse options\n    {\n      // For convenience, we can re-use the exported opengraph-image\n      // size config to also set the ImageResponse's width and height.\n      ...size,\n      fonts: [\n        {\n          name: 'Inter',\n          data: await interSemiBold,\n          style: 'normal',\n          weight: 400,\n        },\n      ],\n    }\n  )\n}\n<head> output <meta property=\"og:image\" content=\"<generated>\" />\n<meta property=\"og:image:alt\" content=\"About Acme\" />\n<meta property=\"og:image:type\" content=\"image/png\" />\n<meta property=\"og:image:width\" content=\"1200\" />\n<meta property=\"og:image:height\" content=\"630\" />\nProps\nThe default export function receives the following props:\nparams (optional)", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-6", "text": "Props\nThe default export function receives the following props:\nparams (optional)\nAn object containing the dynamic route parameters object from the root segment down to the segment opengraph-image or twitter-image is colocated in.\napp/shop/[slug]/opengraph-image.tsx export default function Image({ params }: { params: { slug: string } }) {\n  // ...\n}\nRouteURLparamsapp/shop/opengraph-image.js/shopundefinedapp/shop/[slug]/opengraph-image.js/shop/1{ slug: '1' }app/shop/[tag]/[item]/opengraph-image.js/shop/1/2{ tag: '1', item: '2' }app/shop/[...slug]/opengraph-image.js/shop/1/2{ slug: ['1', '2'] }\nReturns\nThe default export function should return a Blob | ArrayBuffer | TypedArray | DataView | ReadableStream | Response.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-7", "text": "Good to know: ImageResponse satisfies this return type.\nConfig exports\nYou can optionally configure the image's metadata by exporting alt, size, and contentType variables from opengraph-image or twitter-image route.\nOptionTypealtstringsize{ width: number; height: number }contentTypestring - image MIME type\nalt\nopengraph-image.tsx / twitter-image.tsx export const alt = 'My images alt text'\n \nexport default function Image() {}\n<head> output <meta property=\"og:image:alt\" content=\"My images alt text\" />\nsize\nopengraph-image.tsx / twitter-image.tsx export const size = { width: 1200, height: 630 }\n \nexport default function Image() {}\n<head> output <meta property=\"og:image:width\" content=\"1200\" />\n<meta property=\"og:image:height\" content=\"630\" />\ncontentType", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-8", "text": "<meta property=\"og:image:height\" content=\"630\" />\ncontentType\nopengraph-image.tsx / twitter-image.tsx export const contentType = 'image/png'\n \nexport default function Image() {}\n<head> output <meta property=\"og:image:type\" content=\"image/png\" />\nRoute Segment Config\nopengraph-image and twitter-image are specialized Route Handlers that can use the same route segment configuration options as Pages and Layouts.\nOptionTypeDefaultdynamic'auto' | 'force-dynamic' | 'error' | 'force-static''auto'revalidatefalse | 'force-cache' | 0 | numberfalseruntime'nodejs' | 'edge''nodejs'preferredRegion'auto' | 'global' | 'home' | string | string[]'auto'\napp/opengraph-image.tsx export const runtime = 'edge'\n \nexport default function Image() {}\nExamples\nUsing external data", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-9", "text": "export default function Image() {}\nExamples\nUsing external data\nThis example uses the params object and external data to generate the image.\nGood to know:\nBy default, this generated image will be statically optimized. You can configure the individual fetch options or route segments options to change this behavior.\napp/posts/[slug]/opengraph-image.tsx import { ImageResponse } from 'next/server'\n \nexport const runtime = 'edge'\n \nexport const alt = 'About Acme'\nexport const size = {\n  width: 1200,\n  height: 630,\n}\nexport const contentType = 'image/png'\n \nexport default async function Image({ params }: { params: { slug: string } }) {\n  const post = await fetch(`https://.../posts/${params.slug}`).then((res) =>\n    res.json()\n  )\n \n  return new ImageResponse(", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "bcfd80d6f30f-10", "text": "res.json()\n  )\n \n  return new ImageResponse(\n    (\n      <div\n        style={{\n          fontSize: 48,\n          background: 'white',\n          width: '100%',\n          height: '100%',\n          display: 'flex',\n          alignItems: 'center',\n          justifyContent: 'center',\n        }}\n      >\n        {post.title}\n      </div>\n    ),\n    {\n      ...size,\n    }\n  )\n}\nVersion History\nVersionChangesv13.3.0opengraph-image and twitter-image introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/opengraph-image"}
{"id": "136608218ae1-0", "text": "robots.txtAdd or generate a robots.txt file that matches the Robots Exclusion Standard in the root of app directory to tell search engine crawlers which URLs they can access on your site.\nStatic robots.txt\napp/robots.txt User-Agent: *\nAllow: /\nDisallow: /private/\nSitemap: https://acme.com/sitemap.xml\nGenerate a Robots file\nAdd a robots.js or robots.ts file that returns a Robots object.\napp/robots.ts import { MetadataRoute } from 'next'\n \nexport default function robots(): MetadataRoute.Robots {\n  return {\n    rules: {\n      userAgent: '*',\n      allow: '/',\n      disallow: '/private/',\n    },\n    sitemap: 'https://acme.com/sitemap.xml',\n  }\n}\nOutput:\n User-Agent: *\nAllow: /\nDisallow: /private/\nSitemap: https://acme.com/sitemap.xml", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/robots"}
{"id": "136608218ae1-1", "text": "Disallow: /private/\nSitemap: https://acme.com/sitemap.xml\nRobots object\n type Robots = {\n  rules:\n    | {\n        userAgent?: string | string[]\n        allow?: string | string[]\n        disallow?: string | string[]\n        crawlDelay?: number\n      }\n    | Array<{\n        userAgent: string | string[]\n        allow?: string | string[]\n        disallow?: string | string[]\n        crawlDelay?: number\n      }>\n  sitemap?: string | string[]\n  host?: string\n}\nVersion History\nVersionChangesv13.3.0robots introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/robots"}
{"id": "8dac53b20fb9-0", "text": "sitemap.xmlAdd or generate a sitemap.xml file that matches the Sitemaps XML format in the root of app directory to help search engine crawlers crawl your site more efficiently.\nStatic sitemap.xml\napp/sitemap.xml <urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n  <url>\n    <loc>https://acme.com</loc>\n    <lastmod>2023-04-06T15:02:24.021Z</lastmod>\n  </url>\n  <url>\n    <loc>https://acme.com/about</loc>\n    <lastmod>2023-04-06T15:02:24.021Z</lastmod>\n  </url>\n  <url>\n    <loc>https://acme.com/blog</loc>", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/sitemap"}
{"id": "8dac53b20fb9-1", "text": "<url>\n    <loc>https://acme.com/blog</loc>\n    <lastmod>2023-04-06T15:02:24.021Z</lastmod>\n  </url>\n</urlset>\nGenerate a Sitemap\nAdd a sitemap.js or sitemap.ts file that returns Sitemap.\napp/sitemap.ts import { MetadataRoute } from 'next'\n \nexport default function sitemap(): MetadataRoute.Sitemap {\n  return [\n    {\n      url: 'https://acme.com',\n      lastModified: new Date(),\n    },\n    {\n      url: 'https://acme.com/about',\n      lastModified: new Date(),\n    },\n    {\n      url: 'https://acme.com/blog',\n      lastModified: new Date(),\n    },\n  ]\n}\nOutput:", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/sitemap"}
{"id": "8dac53b20fb9-2", "text": "lastModified: new Date(),\n    },\n  ]\n}\nOutput:\nacme.com/sitemap.xml <urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n  <url>\n    <loc>https://acme.com</loc>\n    <lastmod>2023-04-06T15:02:24.021Z</lastmod>\n  </url>\n  <url>\n    <loc>https://acme.com/about</loc>\n    <lastmod>2023-04-06T15:02:24.021Z</lastmod>\n  </url>\n  <url>\n    <loc>https://acme.com/blog</loc>\n    <lastmod>2023-04-06T15:02:24.021Z</lastmod>\n  </url>\n</urlset>", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/sitemap"}
{"id": "8dac53b20fb9-3", "text": "</url>\n</urlset>\nSitemap Return Type\n type Sitemap = Array<{\n  url: string\n  lastModified?: string | Date\n}>\nGood to know\nIn the future, we will support multiple sitemaps and sitemap indexes.\nVersion History\nVersionChangesv13.3.0sitemap introduced.", "source": "https://nextjs.org/docs/app/api-reference/file-conventions/metadata/sitemap"}
{"id": "691420b793cf-0", "text": "cookiesThe cookies function allows you to read the HTTP incoming request cookies from a Server Component or write outgoing request cookies in a Server Action or Route Handler.\nGood to know: cookies() is a Dynamic Function whose returned values cannot be known ahead of time. Using it in a layout or page will opt a route into dynamic rendering at request time.\ncookies().get(name)\nA method that takes a cookie name and returns an object with name and value. If a cookie with name isn't found, it returns undefined. If multiple cookies match, it will only return the first match.\napp/page.js import { cookies } from 'next/headers'\n \nexport default function Page() {\n  const cookieStore = cookies()\n  const theme = cookieStore.get('theme')\n  return '...'\n}\ncookies().getAll()", "source": "https://nextjs.org/docs/app/api-reference/functions/cookies"}
{"id": "691420b793cf-1", "text": "return '...'\n}\ncookies().getAll()\nA method that is similar to get, but returns a list of all the cookies with a matching name. If name is unspecified, it returns all the available cookies.\napp/page.js import { cookies } from 'next/headers'\n \nexport default function Page() {\n  const cookieStore = cookies()\n  return cookieStore.getAll().map((cookie) => (\n    <div key={cookie.name}>\n      <p>Name: {cookie.name}</p>\n      <p>Value: {cookie.value}</p>\n    </div>\n  ))\n}\ncookies().has(name)\nA method that takes a cookie name and returns a boolean based on if the cookie exists (true) or not (false).\napp/page.js import { cookies } from 'next/headers'\n \nexport default function Page() {\n  const cookiesList = cookies()", "source": "https://nextjs.org/docs/app/api-reference/functions/cookies"}
{"id": "691420b793cf-2", "text": "export default function Page() {\n  const cookiesList = cookies()\n  const hasCookie = cookiesList.has('theme')\n  return '...'\n}\ncookies().set(name, value, options)\nA method that takes a cookie name, value, and options and sets the outgoing request cookie.\nGood to know: .set() is only available in a Server Action or Route Handler.\napp/actions.js 'use server'\n \nimport { cookies } from 'next/headers'\n \nasync function create(data) {\n  cookies().set('name', 'lee')\n  // or\n  cookies().set('name', 'lee', { secure: true })\n  // or\n  cookies().set({\n    name: 'name',\n    value: 'lee',\n    httpOnly: true,\n    path: '/',\n  })\n}\nDeleting cookies", "source": "https://nextjs.org/docs/app/api-reference/functions/cookies"}
{"id": "691420b793cf-3", "text": "httpOnly: true,\n    path: '/',\n  })\n}\nDeleting cookies\nTo \"delete\" a cookie, you must set a new cookie with the same name and an empty value. You can also set the maxAge to 0 to expire the cookie immediately.\nGood to know: .set() is only available in a Server Action or Route Handler.\napp/actions.js 'use server'\n \nimport { cookies } from 'next/headers'\n \nasync function create(data) {\n  cookies().set({\n    name: 'name',\n    value: '',\n    expires: new Date('2016-10-05'),\n    path: '/', // For all paths\n  })\n}\nYou can only set cookies that belong to the same domain from which .set() is called. Additionally, the code must be executed on the same protocol (HTTP or HTTPS) as the cookie you want to update.", "source": "https://nextjs.org/docs/app/api-reference/functions/cookies"}
{"id": "691420b793cf-4", "text": "Version History\nVersionChangesv13.0.0cookies introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/cookies"}
{"id": "4a5a91177da5-0", "text": "draftModeThe draftMode function allows you to detect Draft Mode inside a Server Component.\napp/page.js import { draftMode } from 'next/headers'\n \nexport default function Page() {\n  const { isEnabled } = draftMode()\n  return (\n    <main>\n      <h1>My Blog Post</h1>\n      <p>Draft Mode is currently {isEnabled ? 'Enabled' : 'Disabled'}</p>\n    </main>\n  )\n}\nVersion History\nVersionChangesv13.4.0draftMode introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/draft-mode"}
{"id": "3debed7a35b1-0", "text": "fetchNext.js extends the native Web fetch() API to allow each request on the server to set its own persistent caching semantics.\nIn the browser, the cache option indicates how a fetch request will interact with the browser's HTTP cache. With this extension, cache indicates how a server-side fetch request will interact with the framework's persistent HTTP cache.\nYou can call fetch with async and await directly within Server Components.\napp/page.tsx export default async function Page() {\n  // This request should be cached until manually invalidated.\n  // Similar to `getStaticProps`.\n  // `force-cache` is the default and can be omitted.\n  const staticData = await fetch(`https://...`, { cache: 'force-cache' })\n \n  // This request should be refetched on every request.\n  // Similar to `getServerSideProps`.\n  const dynamicData = await fetch(`https://...`, { cache: 'no-store' })", "source": "https://nextjs.org/docs/app/api-reference/functions/fetch"}
{"id": "3debed7a35b1-1", "text": "// This request should be cached with a lifetime of 10 seconds.\n  // Similar to `getStaticProps` with the `revalidate` option.\n  const revalidatedData = await fetch(`https://...`, {\n    next: { revalidate: 10 },\n  })\n \n  return <div>...</div>\n}\nfetch(url, options)\nSince Next.js extends the Web fetch() API, you can use any of the native options available.\nFurther, Next.js polyfills fetch on both the client and the server, so you can use fetch in both Server and Client Components.\noptions.cache\nConfigure how the request should interact with Next.js HTTP cache.\n fetch(`https://...`, { cache: 'force-cache' | 'no-store' })\nforce-cache (default) - Next.js looks for a matching request in its HTTP cache.", "source": "https://nextjs.org/docs/app/api-reference/functions/fetch"}
{"id": "3debed7a35b1-2", "text": "force-cache (default) - Next.js looks for a matching request in its HTTP cache.\nIf there is a match and it is fresh, it will be returned from the cache.\nIf there is no match or a stale match, Next.js will fetch the resource from the remote server and update the cache with the downloaded resource.\nno-store - Next.js fetches the resource from the remote server on every request without looking in the cache, and it will not update the cache with the downloaded resource.\nGood to know:\nIf you don't provide a cache option, Next.js will default to force-cache, unless a dynamic function such as cookies() is used, in which case it will default to no-store.\nThe no-cache option behaves the same way as no-store in Next.js.\noptions.next.revalidate\n fetch(`https://...`, { next: { revalidate: false | 0 | number } })", "source": "https://nextjs.org/docs/app/api-reference/functions/fetch"}
{"id": "3debed7a35b1-3", "text": "Set the cache lifetime of a resource (in seconds).\nfalse - Cache the resource indefinitely. Semantically equivalent to revalidate: Infinity. The HTTP cache may evict older resources over time.\n0 - Prevent the resource from being cached.\nnumber - (in seconds) Specify the resource should have a cache lifetime of at most n seconds.\nGood to know:\nIf an individual fetch() request sets a revalidate number lower than the default revalidate of a route, the whole route revalidation interval will be decreased.\nIf two fetch requests with the same URL in the same route have different revalidate values, the lower value will be used.\nAs a convenience, it is not necessary to set the cache option if revalidate is set to a number since 0 implies cache: 'no-store' and a positive value implies cache: 'force-cache'.", "source": "https://nextjs.org/docs/app/api-reference/functions/fetch"}
{"id": "3debed7a35b1-4", "text": "Conflicting options such as { revalidate: 0, cache: 'force-cache' } or { revalidate: 10, cache: 'no-store' } will cause an error.\nVersion History\nVersionChangesv13.0.0fetch introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/fetch"}
{"id": "b35f8327fbd0-0", "text": "generateImageMetadataYou can use generateImageMetadata to generate different versions of one image or return multiple images for one route segment. This is useful for when you want to avoid hard-coding metadata values, such as for icons.\nParameters\ngenerateImageMetadata function accepts the following parameters:\nparams (optional)\nAn object containing the dynamic route parameters object from the root segment down to the segment generateImageMetadata is called from.\nicon.tsx export function generateImageMetadata({\n  params,\n}: {\n  params: { slug: string }\n}) {\n  // ...\n}\nRouteURLparamsapp/shop/icon.js/shopundefinedapp/shop/[slug]/icon.js/shop/1{ slug: '1' }app/shop/[tag]/[item]/icon.js/shop/1/2{ tag: '1', item: '2' }app/shop/[...slug]/icon.js/shop/1/2{ slug: ['1', '2'] }\nReturns", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-image-metadata"}
{"id": "b35f8327fbd0-1", "text": "Returns\nThe generateImageMetadata function should return an array of objects containing the image's metadata such as alt and size. In addition, each item must include an id value will be passed to the props of the image generating function.\nImage Metadata ObjectTypeidstring (required)altstringsize{ width: number; height: number }contentTypestring\nicon.tsx import { ImageResponse } from 'next/server'\n \nexport function generateImageMetadata() {\n  return [\n    {\n      contentType: 'image/png',\n      size: { width: 48, height: 48 },\n      id: 'small',\n    },\n    {\n      contentType: 'image/png',\n      size: { width: 72, height: 72 },\n      id: 'medium',\n    },\n  ]\n}\n \nexport default function Icon({ id }: { id: string }) {\n  return new ImageResponse(", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-image-metadata"}
{"id": "b35f8327fbd0-2", "text": "return new ImageResponse(\n    (\n      <div\n        style={{\n          width: '100%',\n          height: '100%',\n          display: 'flex',\n          alignItems: 'center',\n          justifyContent: 'center',\n          fontSize: 88,\n          background: '#000',\n          color: '#fafafa',\n        }}\n      >\n        Icon {id}\n      </div>\n    )\n  )\n}\nExamples\nUsing external data\nThis example uses the params object and external data to generate multiple Open Graph images for a route segment.\napp/products/[id]/opengraph-image.tsx import { ImageResponse } from 'next/server'\nimport { getCaptionForImage, getOGImages } from '@/app/utils/images'\n \nexport async function generateImageMetadata({\n  params,\n}: {\n  params: { id: string }\n}) {", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-image-metadata"}
{"id": "b35f8327fbd0-3", "text": "params,\n}: {\n  params: { id: string }\n}) {\n  const images = await getOGImages(params.id)\n \n  return images.map((image, idx) => ({\n    id: idx,\n    size: { width: 1200, height: 600 },\n    alt: image.text,\n    contentType: 'image/png',\n  }))\n}\n \nexport default async function Image({\n  params,\n  id,\n}: {\n  params: { id: string }\n  id: number\n}) {\n  const productId = params.id\n  const imageId = id\n  const text = await getCaptionForImage(productId, imageId)\n \n  return new ImageResponse(\n    (\n      <div\n        style={\n          {\n            // ...\n          }\n        }\n      >\n        {text}\n      </div>", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-image-metadata"}
{"id": "b35f8327fbd0-4", "text": "}\n        }\n      >\n        {text}\n      </div>\n    )\n  )\n}\nVersion History\nVersionChangesv13.3.0generateImageMetadata introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-image-metadata"}
{"id": "1d048b70a39d-0", "text": "Metadata Object and generateMetadata OptionsThis page covers all Config-based Metadata options with generateMetadata and the static metadata object.\nlayout.tsx / page.tsx import { Metadata } from 'next'\n \n// either Static metadata\nexport const metadata: Metadata = {\n  title: '...',\n}\n \n// or Dynamic metadata\nexport async function generateMetadata({ params }) {\n  return {\n    title: '...',\n  }\n}\nGood to know:\nThe metadata object and generateMetadata function exports are only supported in Server Components.\nYou cannot export both the metadata object and generateMetadata function from the same route segment.\nThe metadata object\nTo define static metadata, export a Metadata object from a layout.js or page.js file.\nlayout.tsx / page.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: '...',\n  description: '...',\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-1", "text": "title: '...',\n  description: '...',\n}\n \nexport default function Page() {}\nSee the Metadata Fields for a complete list of supported options.\ngenerateMetadata function\nDynamic metadata depends on dynamic information, such as the current route parameters, external data, or metadata in parent segments, can be set by exporting a generateMetadata function that returns a Metadata object.\napp/products/[id]/page.tsx import { Metadata, ResolvingMetadata } from 'next'\n \ntype Props = {\n  params: { id: string }\n  searchParams: { [key: string]: string | string[] | undefined }\n}\n \nexport async function generateMetadata(\n  { params, searchParams }: Props,\n  parent: ResolvingMetadata\n): Promise<Metadata> {\n  // read route params\n  const id = params.id\n \n  // fetch data", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-2", "text": "// read route params\n  const id = params.id\n \n  // fetch data\n  const product = await fetch(`https://.../${id}`).then((res) => res.json())\n \n  // optionally access and extend (rather than replace) parent metadata\n  const previousImages = (await parent).openGraph?.images || []\n \n  return {\n    title: product.title,\n    openGraph: {\n      images: ['/some-specific-page-image.jpg', ...previousImages],\n    },\n  }\n}\n \nexport default function Page({ params, searchParams }: Props) {}\nParameters\ngenerateMetadata function accepts the following parameters:\nprops - An object containing the parameters of the current route:\nparams - An object containing the dynamic route parameters object from the root segment down to the segment generateMetadata is called from. Examples:", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-3", "text": "RouteURLparamsapp/shop/[slug]/page.js/shop/1{ slug: '1' }app/shop/[tag]/[item]/page.js/shop/1/2{ tag: '1', item: '2' }app/shop/[...slug]/page.js/shop/1/2{ slug: ['1', '2'] }\nsearchParams - An object containing the current URL's search params. Examples:\nURLsearchParams/shop?a=1{ a: '1' }/shop?a=1&b=2{ a: '1', b: '2' }/shop?a=1&a=2{ a: ['1', '2'] }\nparent - A promise of the resolved metadata from parent route segments.\nReturns\ngenerateMetadata should return a Metadata object containing one or more metadata fields.\nGood to know:", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-4", "text": "generateMetadata should return a Metadata object containing one or more metadata fields.\nGood to know:\nIf metadata doesn't depend on runtime information, it should be defined using the static metadata object rather than generateMetadata.\nWhen rendering a route, Next.js will automatically deduplicate fetch requests for the same data across generateMetadata, generateStaticParams, Layouts, Pages, and Server Components. React cache can be used if fetch is unavailable.\nsearchParams are only available in page.js segments.\nThe redirect() and notFound() Next.js methods can also be used inside generateMetadata.\nMetadata Fields\ntitle\nThe title attribute is used to set the title of the document. It can be defined as a simple string or an optional template object.\nString\nlayout.js / page.js export const metadata = {\n  title: 'Next.js',\n}\n<head> output <title>Next.js</title>\nTemplate object", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-5", "text": "}\n<head> output <title>Next.js</title>\nTemplate object\napp/layout.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: {\n    template: '...',\n    default: '...',\n    absolute: '...',\n  },\n}\nDefault\ntitle.default can be used to provide a fallback title to child route segments that don't define a title.\napp/layout.tsx import type { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: {\n    default: 'Acme',\n  },\n}\napp/about/page.tsx import type { Metadata } from 'next'\n \nexport const metadata: Metadata = {}\n \n// Output: <title>Acme</title>\nTemplate\ntitle.template can be used to add a prefix or a suffix to titles defined in child route segments.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-6", "text": "app/layout.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: {\n    template: '%s | Acme',\n    default: 'Acme', // a default is required when creating a template\n  },\n}\napp/about/page.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: 'About',\n}\n \n// Output: <title>About | Acme</title>\nGood to know:\ntitle.template applies to child route segments and not the segment it's defined in. This means:\ntitle.default is required when you add a title.template.\ntitle.template defined in layout.js will not apply to a title defined in a page.js of the same route segment.\ntitle.template defined in page.js has no effect because a page is always the terminating segment (it doesn't have any children route segments).", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-7", "text": "title.template has no effect if a route has not defined a title or title.default.\nAbsolute\ntitle.absolute can be used to provide a title that ignores title.template set in parent segments.\napp/layout.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: {\n    template: '%s | Acme',\n  },\n}\napp/about/page.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: {\n    absolute: 'About',\n  },\n}\n \n// Output: <title>About</title>\nGood to know:\nlayout.js\ntitle (string) and title.default define the default title for child segments (that do not define their own title). It will augment title.template from the closest parent segment if it exists.\ntitle.absolute defines the default title for child segments. It ignores title.template from parent segments.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-8", "text": "title.absolute defines the default title for child segments. It ignores title.template from parent segments.\ntitle.template defines a new title template for child segments.\npage.js\nIf a page does not define its own title the closest parents resolved title will be used.\ntitle (string) defines the routes title. It will augment title.template from the closest parent segment if it exists.\ntitle.absolute defines the route title. It ignores title.template from parent segments.\ntitle.template has no effect in page.js because a page is always the terminating segment of a route.\ndescription\nlayout.js / page.js export const metadata = {\n  description: 'The React Framework for the Web',\n}\n<head> output <meta name=\"description\" content=\"The React Framework for the Web\" />\nBasic Fields\nlayout.js / page.js export const metadata = {\n  generator: 'Next.js',\n  applicationName: 'Next.js',", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-9", "text": "generator: 'Next.js',\n  applicationName: 'Next.js',\n  referrer: 'origin-when-cross-origin',\n  keywords: ['Next.js', 'React', 'JavaScript'],\n  authors: [{ name: 'Seb' }, { name: 'Josh', url: 'https://nextjs.org' }],\n  colorScheme: 'dark',\n  creator: 'Jiachi Liu',\n  publisher: 'Sebastian Markb\u00e5ge',\n  formatDetection: {\n    email: false,\n    address: false,\n    telephone: false,\n  },\n}\n<head> output <meta name=\"application-name\" content=\"Next.js\" />\n<meta name=\"author\" content=\"Seb\" />\n<link rel=\"author\" href=\"https://nextjs.org\" />\n<meta name=\"author\" content=\"Josh\" />\n<meta name=\"generator\" content=\"Next.js\" />", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-10", "text": "<meta name=\"generator\" content=\"Next.js\" />\n<meta name=\"keywords\" content=\"Next.js,React,JavaScript\" />\n<meta name=\"referrer\" content=\"origin-when-cross-origin\" />\n<meta name=\"color-scheme\" content=\"dark\" />\n<meta name=\"creator\" content=\"Jiachi Liu\" />\n<meta name=\"publisher\" content=\"Sebastian Markb\u00e5ge\" />\n<meta name=\"format-detection\" content=\"telephone=no, address=no, email=no\" />\nmetadataBase\nmetadataBase is a convenience option to set a base URL prefix for metadata fields that require a fully qualified URL.\nmetadataBase allows URL-based metadata fields defined in the current route segment and below to use a relative path instead of an otherwise required absolute URL.\nThe field's relative path will be composed with metadataBase to form a fully qualified URL.\nIf not configured, metadataBase is automatically populated with a default value.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-11", "text": "If not configured, metadataBase is automatically populated with a default value.\nlayout.js / page.js export const metadata = {\n  metadataBase: new URL('https://acme.com'),\n  alternates: {\n    canonical: '/',\n    languages: {\n      'en-US': '/en-US',\n      'de-DE': '/de-DE',\n    },\n  },\n  openGraph: {\n    images: '/og-image.png',\n  },\n}\n<head> output <link rel=\"canonical\" href=\"https://acme.com\" />\n<link rel=\"alternate\" hreflang=\"en-US\" href=\"https://acme.com/en-US\" />\n<link rel=\"alternate\" hreflang=\"de-DE\" href=\"https://acme.com/de-DE\" />\n<meta property=\"og:image\" content=\"https://acme.com/og-image.png\" />\nGood to know:", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-12", "text": "Good to know:\nmetadataBase is typically set in root app/layout.js to apply to URL-based metadata fields across all routes.\nAll URL-based metadata fields that require absolute URLs can be configured with a metadataBase option.\nmetadataBase can contain a subdomain e.g. https://app.acme.com or base path e.g. https://acme.com/start/from/here\nIf a metadata field provides an absolute URL, metadataBase will be ignored.\nUsing a relative path in a URL-based metadata field without configuring a metadataBase will cause a build error.\nNext.js will normalize duplicate slashes between metadataBase (e.g. https://acme.com/) and a relative field (e.g. /path) to a single slash (e.g. https://acme.com/path)\nDefault value\nIf not configured, metadataBase has a default value", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-13", "text": "Default value\nIf not configured, metadataBase has a default value\nWhen VERCEL_URL is detected: https://${process.env.VERCEL_URL} otherwise it falls back to http://localhost:${process.env.PORT || 3000}.\nWhen overriding the default, we recommend using environment variables to compute the URL. This allows configuring a URL for local development, staging, and production environments.\nURL Composition\nURL composition favors developer intent over default directory traversal semantics.\nTrailing slashes between metadataBase and metadata fields are normalized.\nAn \"absolute\" path in a metadata field (that typically would replace the whole URL path) is treated as a \"relative\" path (starting from the end of metadataBase).\nFor example, given the following metadataBase:\napp/layout.tsx import { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  metadataBase: new URL('https://acme.com'),\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-14", "text": "metadataBase: new URL('https://acme.com'),\n}\nAny metadata fields that inherit the above metadataBase and set their own value will be resolved as follows:\nmetadata fieldResolved URL/https://acme.com./https://acme.compaymentshttps://acme.com/payments/paymentshttps://acme.com/payments./paymentshttps://acme.com/payments../paymentshttps://acme.com/paymentshttps://beta.acme.com/paymentshttps://beta.acme.com/payments\nopenGraph\nlayout.js / page.js export const metadata = {\n  openGraph: {\n    title: 'Next.js',\n    description: 'The React Framework for the Web',\n    url: 'https://nextjs.org',\n    siteName: 'Next.js',\n    images: [\n      {\n        url: 'https://nextjs.org/og.png',\n        width: 800,", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-15", "text": "width: 800,\n        height: 600,\n      },\n      {\n        url: 'https://nextjs.org/og-alt.png',\n        width: 1800,\n        height: 1600,\n        alt: 'My custom alt',\n      },\n    ],\n    locale: 'en_US',\n    type: 'website',\n  },\n}\n<head> output <meta property=\"og:title\" content=\"Next.js\" />\n<meta property=\"og:description\" content=\"The React Framework for the Web\" />\n<meta property=\"og:url\" content=\"https://nextjs.org/\" />\n<meta property=\"og:site_name\" content=\"Next.js\" />\n<meta property=\"og:locale\" content=\"en_US\" />\n<meta property=\"og:image:url\" content=\"https://nextjs.org/og.png\" />\n<meta property=\"og:image:width\" content=\"800\" />", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-16", "text": "<meta property=\"og:image:width\" content=\"800\" />\n<meta property=\"og:image:height\" content=\"600\" />\n<meta property=\"og:image:url\" content=\"https://nextjs.org/og-alt.png\" />\n<meta property=\"og:image:width\" content=\"1800\" />\n<meta property=\"og:image:height\" content=\"1600\" />\n<meta property=\"og:image:alt\" content=\"My custom alt\" />\n<meta property=\"og:type\" content=\"website\" />\nlayout.js / page.js export const metadata = {\n  openGraph: {\n    title: 'Next.js',\n    description: 'The React Framework for the Web',\n    type: 'article',\n    publishedTime: '2023-01-01T00:00:00.000Z',\n    authors: ['Seb', 'Josh'],\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-17", "text": "authors: ['Seb', 'Josh'],\n  },\n}\n<head> output <meta property=\"og:title\" content=\"Next.js\" />\n<meta property=\"og:description\" content=\"The React Framework for the Web\" />\n<meta property=\"og:type\" content=\"article\" />\n<meta property=\"article:published_time\" content=\"2023-01-01T00:00:00.000Z\" />\n<meta property=\"article:author\" content=\"Seb\" />\n<meta property=\"article:author\" content=\"Josh\" />\nGood to know:\nIt may be more convenient to use the file-based Metadata API for Open Graph images. Rather than having to sync the config export with actual files, the file-based API will automatically generate the correct metadata for you.\nrobots\n import type { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  robots: {\n    index: false,", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-18", "text": "export const metadata: Metadata = {\n  robots: {\n    index: false,\n    follow: true,\n    nocache: true,\n    googleBot: {\n      index: true,\n      follow: false,\n      noimageindex: true,\n      'max-video-preview': -1,\n      'max-image-preview': 'large',\n      'max-snippet': -1,\n    },\n  },\n}\n<head> output <meta name=\"robots\" content=\"noindex, follow, nocache\" />\n<meta\n  name=\"googlebot\"\n  content=\"index, nofollow, noimageindex, max-video-preview:-1, max-image-preview:large, max-snippet:-1\"\n/>\nicons", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-19", "text": "/>\nicons\nGood to know: We recommend using the file-based Metadata API for icons where possible. Rather than having to sync the config export with actual files, the file-based API will automatically generate the correct metadata for you.\nlayout.js / page.js export const metadata = {\n  icons: {\n    icon: '/icon.png',\n    shortcut: '/shortcut-icon.png',\n    apple: '/apple-icon.png',\n    other: {\n      rel: 'apple-touch-icon-precomposed',\n      url: '/apple-touch-icon-precomposed.png',\n    },\n  },\n}\n<head> output <link rel=\"shortcut icon\" href=\"/shortcut-icon.png\" />\n<link rel=\"icon\" href=\"/icon.png\" />\n<link rel=\"apple-touch-icon\" href=\"/apple-icon.png\" />\n<link\n  rel=\"apple-touch-icon-precomposed\"\n  href=\"/apple-touch-icon-precomposed.png\"\n/>", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-20", "text": "href=\"/apple-touch-icon-precomposed.png\"\n/>\nlayout.js / page.js export const metadata = {\n  icons: {\n    icon: [{ url: '/icon.png' }, new URL('/icon.png', 'https://example.com')],\n    shortcut: ['/shortcut-icon.png'],\n    apple: [\n      { url: '/apple-icon.png' },\n      { url: '/apple-icon-x3.png', sizes: '180x180', type: 'image/png' },\n    ],\n    other: [\n      {\n        rel: 'apple-touch-icon-precomposed',\n        url: '/apple-touch-icon-precomposed.png',\n      },\n    ],\n  },\n}\n<head> output <link rel=\"shortcut icon\" href=\"/shortcut-icon.png\" />\n<link rel=\"icon\" href=\"/icon.png\" />\n<link rel=\"apple-touch-icon\" href=\"/apple-icon.png\" />\n<link", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-21", "text": "<link rel=\"apple-touch-icon\" href=\"/apple-icon.png\" />\n<link\n  rel=\"apple-touch-icon-precomposed\"\n  href=\"/apple-touch-icon-precomposed.png\"\n/>\n<link rel=\"icon\" href=\"https://example.com/icon.png\" />\n<link\n  rel=\"apple-touch-icon\"\n  href=\"/apple-icon-x3.png\"\n  sizes=\"180x180\"\n  type=\"image/png\"\n/>\nGood to know: The msapplication-* meta tags are no longer supported in Chromium builds of Microsoft Edge, and thus no longer needed.\nthemeColor\nLearn more about theme-color.\nSimple theme color\nlayout.js / page.js export const metadata = {\n  themeColor: 'black',\n}\n<head> output <meta name=\"theme-color\" content=\"black\" />\nWith media attribute\nlayout.js / page.js export const metadata = {\n  themeColor: [", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-22", "text": "layout.js / page.js export const metadata = {\n  themeColor: [\n    { media: '(prefers-color-scheme: light)', color: 'cyan' },\n    { media: '(prefers-color-scheme: dark)', color: 'black' },\n  ],\n}\n<head> output <meta name=\"theme-color\" media=\"(prefers-color-scheme: light)\" content=\"cyan\" />\n<meta name=\"theme-color\" media=\"(prefers-color-scheme: dark)\" content=\"black\" />\nmanifest\nA web application manifest, as defined in the Web Application Manifest specification.\nlayout.js / page.js export const metadata = {\n  manifest: 'https://nextjs.org/manifest.json',\n}\n<head> output <link rel=\"manifest\" href=\"https://nextjs.org/manifest.json\" />\ntwitter\nLearn more about the Twitter Card markup reference.\nlayout.js / page.js export const metadata = {", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-23", "text": "layout.js / page.js export const metadata = {\n  twitter: {\n    card: 'summary_large_image',\n    title: 'Next.js',\n    description: 'The React Framework for the Web',\n    siteId: '1467726470533754880',\n    creator: '@nextjs',\n    creatorId: '1467726470533754880',\n    images: ['https://nextjs.org/og.png'],\n  },\n}\n<head> output <meta name=\"twitter:card\" content=\"summary_large_image\" />\n<meta name=\"twitter:site:id\" content=\"1467726470533754880\" />\n<meta name=\"twitter:creator\" content=\"@nextjs\" />\n<meta name=\"twitter:creator:id\" content=\"1467726470533754880\" />\n<meta name=\"twitter:title\" content=\"Next.js\" />", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-24", "text": "<meta name=\"twitter:title\" content=\"Next.js\" />\n<meta name=\"twitter:description\" content=\"The React Framework for the Web\" />\n<meta name=\"twitter:image\" content=\"https://nextjs.org/og.png\" />\nlayout.js / page.js export const metadata = {\n  twitter: {\n    card: 'app',\n    title: 'Next.js',\n    description: 'The React Framework for the Web',\n    siteId: '1467726470533754880',\n    creator: '@nextjs',\n    creatorId: '1467726470533754880',\n    images: {\n      url: 'https://nextjs.org/og.png',\n      alt: 'Next.js Logo',\n    },\n    app: {\n      name: 'twitter_app',\n      id: {\n        iphone: 'twitter_app://iphone',\n        ipad: 'twitter_app://ipad',", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-25", "text": "ipad: 'twitter_app://ipad',\n        googleplay: 'twitter_app://googleplay',\n      },\n      url: {\n        iphone: 'https://iphone_url',\n        ipad: 'https://ipad_url',\n      },\n    },\n  },\n}\n<head> output <meta name=\"twitter:site:id\" content=\"1467726470533754880\" />\n<meta name=\"twitter:creator\" content=\"@nextjs\" />\n<meta name=\"twitter:creator:id\" content=\"1467726470533754880\" />\n<meta name=\"twitter:title\" content=\"Next.js\" />\n<meta name=\"twitter:description\" content=\"The React Framework for the Web\" />\n<meta name=\"twitter:card\" content=\"app\" />\n<meta name=\"twitter:image\" content=\"https://nextjs.org/og.png\" />\n<meta name=\"twitter:image:alt\" content=\"Next.js Logo\" />", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-26", "text": "<meta name=\"twitter:image:alt\" content=\"Next.js Logo\" />\n<meta name=\"twitter:app:name:iphone\" content=\"twitter_app\" />\n<meta name=\"twitter:app:id:iphone\" content=\"twitter_app://iphone\" />\n<meta name=\"twitter:app:id:ipad\" content=\"twitter_app://ipad\" />\n<meta name=\"twitter:app:id:googleplay\" content=\"twitter_app://googleplay\" />\n<meta name=\"twitter:app:url:iphone\" content=\"https://iphone_url\" />\n<meta name=\"twitter:app:url:ipad\" content=\"https://ipad_url\" />\n<meta name=\"twitter:app:name:ipad\" content=\"twitter_app\" />\n<meta name=\"twitter:app:name:googleplay\" content=\"twitter_app\" />\nviewport", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-27", "text": "<meta name=\"twitter:app:name:googleplay\" content=\"twitter_app\" />\nviewport\nGood to know: The viewport meta tag is automatically set with the following default values. Usually, manual configuration is unnecessary as the default is sufficient. However, the information is provided for completeness.\nlayout.js / page.js export const metadata = {\n  viewport: {\n    width: 'device-width',\n    initialScale: 1,\n    maximumScale: 1,\n  },\n}\n<head> output <meta\n  name=\"viewport\"\n  content=\"width=device-width, initial-scale=1, maximum-scale=1\"\n/>\nverification\nlayout.js / page.js export const metadata = {\n  verification: {\n    google: 'google',\n    yandex: 'yandex',\n    yahoo: 'yahoo',\n    other: {\n      me: ['my-email', 'my-link'],\n    },\n  },", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-28", "text": "me: ['my-email', 'my-link'],\n    },\n  },\n}\n<head> output <meta name=\"google-site-verification\" content=\"google\" />\n<meta name=\"y_key\" content=\"yahoo\" />\n<meta name=\"yandex-verification\" content=\"yandex\" />\n<meta name=\"me\" content=\"my-email\" />\n<meta name=\"me\" content=\"my-link\" />\nappleWebApp\nlayout.js / page.js export const metadata = {\n  itunes: {\n    appId: 'myAppStoreID',\n    appArgument: 'myAppArgument',\n  },\n  appleWebApp: {\n    title: 'Apple Web App',\n    statusBarStyle: 'black-translucent',\n    startupImage: [\n      '/assets/startup/apple-touch-startup-image-768x1004.png',\n      {", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-29", "text": "{\n        url: '/assets/startup/apple-touch-startup-image-1536x2008.png',\n        media: '(device-width: 768px) and (device-height: 1024px)',\n      },\n    ],\n  },\n}\n<head> output <meta\n  name=\"apple-itunes-app\"\n  content=\"app-id=myAppStoreID, app-argument=myAppArgument\"\n/>\n<meta name=\"apple-mobile-web-app-capable\" content=\"yes\" />\n<meta name=\"apple-mobile-web-app-title\" content=\"Apple Web App\" />\n<link\n  href=\"/assets/startup/apple-touch-startup-image-768x1004.png\"\n  rel=\"apple-touch-startup-image\"\n/>\n<link\n  href=\"/assets/startup/apple-touch-startup-image-1536x2008.png\"", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-30", "text": "href=\"/assets/startup/apple-touch-startup-image-1536x2008.png\"\n  media=\"(device-width: 768px) and (device-height: 1024px)\"\n  rel=\"apple-touch-startup-image\"\n/>\n<meta\n  name=\"apple-mobile-web-app-status-bar-style\"\n  content=\"black-translucent\"\n/>\nalternates\nlayout.js / page.js export const metadata = {\n  alternates: {\n    canonical: 'https://nextjs.org',\n    languages: {\n      'en-US': 'https://nextjs.org/en-US',\n      'de-DE': 'https://nextjs.org/de-DE',\n    },\n    media: {\n      'only screen and (max-width: 600px)': 'https://nextjs.org/mobile',\n    },\n    types: {\n      'application/rss+xml': 'https://nextjs.org/rss',", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-31", "text": "types: {\n      'application/rss+xml': 'https://nextjs.org/rss',\n    },\n  },\n}\n<head> output <link rel=\"canonical\" href=\"https://nextjs.org\" />\n<link rel=\"alternate\" hreflang=\"en-US\" href=\"https://nextjs.org/en-US\" />\n<link rel=\"alternate\" hreflang=\"de-DE\" href=\"https://nextjs.org/de-DE\" />\n<link\n  rel=\"alternate\"\n  media=\"only screen and (max-width: 600px)\"\n  href=\"https://nextjs.org/mobile\"\n/>\n<link\n  rel=\"alternate\"\n  type=\"application/rss+xml\"\n  href=\"https://nextjs.org/rss\"\n/>\nappLinks\nlayout.js / page.js export const metadata = {\n  appLinks: {\n    ios: {\n      url: 'https://nextjs.org/ios',", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-32", "text": "ios: {\n      url: 'https://nextjs.org/ios',\n      app_store_id: 'app_store_id',\n    },\n    android: {\n      package: 'com.example.android/package',\n      app_name: 'app_name_android',\n    },\n    web: {\n      url: 'https://nextjs.org/web',\n      should_fallback: true,\n    },\n  },\n}\n<head> output <meta property=\"al:ios:url\" content=\"https://nextjs.org/ios\" />\n<meta property=\"al:ios:app_store_id\" content=\"app_store_id\" />\n<meta property=\"al:android:package\" content=\"com.example.android/package\" />\n<meta property=\"al:android:app_name\" content=\"app_name_android\" />\n<meta property=\"al:web:url\" content=\"https://nextjs.org/web\" />", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-33", "text": "<meta property=\"al:web:url\" content=\"https://nextjs.org/web\" />\n<meta property=\"al:web:should_fallback\" content=\"true\" />\narchives\nDescribes a collection of records, documents, or other materials of historical interest (source).\nlayout.js / page.js export const metadata = {\n  archives: ['https://nextjs.org/13'],\n}\n<head> output <link rel=\"archives\" href=\"https://nextjs.org/13\" />\nassets\nlayout.js / page.js export const metadata = {\n  assets: ['https://nextjs.org/assets'],\n}\n<head> output <link rel=\"assets\" href=\"https://nextjs.org/assets\" />\nbookmarks\nlayout.js / page.js export const metadata = {\n  bookmarks: ['https://nextjs.org/13'],\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-34", "text": "bookmarks: ['https://nextjs.org/13'],\n}\n<head> output <link rel=\"bookmarks\" href=\"https://nextjs.org/13\" />\ncategory\nlayout.js / page.js export const metadata = {\n  category: 'technology',\n}\n<head> output <meta name=\"category\" content=\"technology\" />\nother\nAll metadata options should be covered using the built-in support. However, there may be custom metadata tags specific to your site, or brand new metadata tags just released. You can use the other option to render any custom metadata tag.\nlayout.js / page.js export const metadata = {\n  other: {\n    custom: 'meta',\n  },\n}\n<head> output <meta name=\"custom\" content=\"meta\" />\nUnsupported Metadata\nThe following metadata types do not currently have built-in support. However, they can still be rendered in the layout or page itself.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-35", "text": "MetadataRecommendation<meta http-equiv=\"...\">Use appropriate HTTP Headers via redirect(), Middleware, Security Headers<base>Render the tag in the layout or page itself.<noscript>Render the tag in the layout or page itself.<style>Learn more about styling in Next.js.<script>Learn more about using scripts.<link rel=\"stylesheet\" />import stylesheets directly in the layout or page itself.<link rel=\"preload />Use ReactDOM preload method<link rel=\"preconnect\" />Use ReactDOM preconnect method<link rel=\"dns-prefetch\" />Use ReactDOM prefetchDNS method\nResource hints\nThe <link> element has a number of rel keywords that can be used to hint to the browser that a external resource is likely to be needed. The browser uses this information to apply preloading optimizations depending on the keyword.\nWhile the Metadata API doesn't directly support these hints, you can use new ReactDOM methods to safely insert them into the <head> of the document.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-36", "text": "app/preload-resources.tsx 'use client'\n \nimport ReactDOM from 'react-dom'\n \nexport function PreloadResources() {\n  ReactDOM.preload('...', { as: '...' })\n  ReactDOM.preconnect('...', { crossOrigin: '...' })\n  ReactDOM.prefetchDNS('...')\n \n  return null\n}\n<link rel=\"preload\">\nStart loading a resource early in the page rendering (browser) lifecycle. MDN Docs.\n ReactDOM.preload(href: string, options: { as: string })\n<head> output <link rel=\"preload\" href=\"...\" as=\"...\" />\n<link rel=\"preconnect\">\nPreemptively initiate a connection to an origin. MDN Docs.\n ReactDOM.preconnect(href: string, options?: { crossOrigin?: string })\n<head> output <link rel=\"preconnect\" href=\"...\" crossorigin />\n<link rel=\"dns-prefetch\">", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-37", "text": "<link rel=\"dns-prefetch\">\nAttempt to resolve a domain name before resources get requested. MDN Docs.\n ReactDOM.prefetchDNS(href: string)\n<head> output <link rel=\"dns-prefetch\" href=\"...\" />\nGood to know:\nThese methods are currently only supported in Client Components, which are still Server Side Rendered on initial page load.\nNext.js in-built features such as next/font, next/image and next/script automatically handle relevant resource hints.\nReact 18.3 does not yet include type definitions for ReactDOM.preload, ReactDOM.preconnect, and ReactDOM.preconnectDNS. You can use // @ts-ignore as a temporary solution to avoid type errors.\nTypes\nYou can add type safety to your metadata by using the Metadata type. If you are using the built-in TypeScript plugin in your IDE, you do not need to manually add the type, but you can still explicitly add it if you want.\nmetadata object", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-38", "text": "metadata object\n import type { Metadata } from 'next'\n \nexport const metadata: Metadata = {\n  title: 'Next.js',\n}\ngenerateMetadata function\nRegular function\n import type { Metadata } from 'next'\n \nexport function generateMetadata(): Metadata {\n  return {\n    title: 'Next.js',\n  }\n}\nAsync function\n import type { Metadata } from 'next'\n \nexport async function generateMetadata(): Promise<Metadata> {\n  return {\n    title: 'Next.js',\n  }\n}\nWith segment props\n import type { Metadata } from 'next'\n \ntype Props = {\n  params: { id: string }\n  searchParams: { [key: string]: string | string[] | undefined }\n}\n \nexport function generateMetadata({ params, searchParams }: Props): Metadata {\n  return {\n    title: 'Next.js',", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "1d048b70a39d-39", "text": "return {\n    title: 'Next.js',\n  }\n}\n \nexport default function Page({ params, searchParams }: Props) {}\nWith parent metadata\n import type { Metadata, ResolvingMetadata } from 'next'\n \nexport async function generateMetadata(\n  { params, searchParams }: Props,\n  parent: ResolvingMetadata\n): Promise<Metadata> {\n  return {\n    title: 'Next.js',\n  }\n}\nJavaScript Projects\nFor JavaScript projects, you can use JSDoc to add type safety.\n /** @type {import(\"next\").Metadata} */\nexport const metadata = {\n  title: 'Next.js',\n}\nVersion History\nVersionChangesv13.2.0metadata and generateMetadata introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-metadata"}
{"id": "6ea27c9f4feb-0", "text": "generateStaticParamsThe generateStaticParams function can be used in combination with dynamic route segments to statically generate routes at build time instead of on-demand at request time.\napp/blog/[slug]/page.js // Return a list of `params` to populate the [slug] dynamic segment\nexport async function generateStaticParams() {\n  const posts = await fetch('https://.../posts').then((res) => res.json())\n \n  return posts.map((post) => ({\n    slug: post.slug,\n  }))\n}\n \n// Multiple versions of this page will be statically generated\n// using the `params` returned by `generateStaticParams`\nexport default function Page({ params }) {\n  const { slug } = params\n  // ...\n}\nGood to know\nYou can use the dynamicParams segment config option to control what happens when a dynamic segment is visited that was not generated with generateStaticParams.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-1", "text": "During next dev, generateStaticParams will be called when you navigate to a route.\nDuring next build, generateStaticParams runs before the corresponding Layouts or Pages are generated.\nDuring revalidation (ISR), generateStaticParams will not be called again.\ngenerateStaticParams replaces the getStaticPaths function in the Pages Router.\nParameters\noptions.params (optional)\nIf multiple dynamic segments in a route use generateStaticParams, the child generateStaticParams function is executed once for each set of params the parent generates.\nThe params object contains the populated params from the parent generateStaticParams, which can be used to generate the params in a child segment.\nReturns\ngenerateStaticParams should return an array of objects where each object represents the populated dynamic segments of a single route.\nEach property in the object is a dynamic segment to be filled in for the route.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-2", "text": "Each property in the object is a dynamic segment to be filled in for the route.\nThe properties name is the segment's name, and the properties value is what that segment should be filled in with.\nExample RoutegenerateStaticParams Return Type/product/[id]{ id: string }[]/products/[category]/[product]{ category: string, product: string }[]/products/[...slug]{ slug: string[] }[]\nSingle Dynamic Segment\napp/product/[id]/page.tsx export function generateStaticParams() {\n  return [{ id: '1' }, { id: '2' }, { id: '3' }]\n}\n \n// Three versions of this page will be statically generated\n// using the `params` returned by `generateStaticParams`\n// - /product/1\n// - /product/2\n// - /product/3", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-3", "text": "// - /product/2\n// - /product/3\nexport default function Page({ params }: { params: { id: string } }) {\n  const { id } = params\n  // ...\n}\nMultiple Dynamic Segments\napp/products/[category]/[product]/page.tsx export function generateStaticParams() {\n  return [\n    { category: 'a', product: '1' },\n    { category: 'b', product: '2' },\n    { category: 'c', product: '3' },\n  ]\n}\n \n// Three versions of this page will be statically generated\n// using the `params` returned by `generateStaticParams`\n// - /products/a/1\n// - /products/b/2\n// - /products/c/3\nexport default function Page({\n  params,\n}: {\n  params: { category: string; product: string }", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-4", "text": "params,\n}: {\n  params: { category: string; product: string }\n}) {\n  const { category, product } = params\n  // ...\n}\nCatch-all Dynamic Segment\napp/product/[...slug]/page.tsx export function generateStaticParams() {\n  return [{ slug: ['a', '1'] }, { slug: ['b', '2'] }, { slug: ['c', '3'] }]\n}\n \n// Three versions of this page will be statically generated\n// using the `params` returned by `generateStaticParams`\n// - /product/a/1\n// - /product/b/2\n// - /product/c/3\nexport default function Page({ params }: { params: { slug: string[] } }) {\n  const { slug } = params\n  // ...\n}\nExamples\nMultiple Dynamic Segments in a Route", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-5", "text": "// ...\n}\nExamples\nMultiple Dynamic Segments in a Route\nYou can generate params for dynamic segments above the current layout or page, but not below. For example, given the app/products/[category]/[product] route:\napp/products/[category]/[product]/page.js can generate params for both [category] and [product].\napp/products/[category]/layout.js can only generate params for [category].\nThere are two approaches to generating params for a route with multiple dynamic segments:\nGenerate params from the bottom up\nGenerate multiple dynamic segments from the child route segment.\napp/products/[category]/[product]/page.tsx // Generate segments for both [category] and [product]\nexport async function generateStaticParams() {\n  const products = await fetch('https://.../products').then((res) => res.json())\n \n  return products.map((product) => ({\n    category: product.category.slug,", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-6", "text": "return products.map((product) => ({\n    category: product.category.slug,\n    product: product.id,\n  }))\n}\n \nexport default function Page({\n  params,\n}: {\n  params: { category: string; product: string }\n}) {\n  // ...\n}\nGenerate params from the top down\nGenerate the parent segments first and use the result to generate the child segments.\napp/products/[category]/layout.tsx // Generate segments for [category]\nexport async function generateStaticParams() {\n  const products = await fetch('https://.../products').then((res) => res.json())\n \n  return products.map((product) => ({\n    category: product.category.slug,\n  }))\n}\n \nexport default function Layout({ params }: { params: { category: string } }) {\n  // ...\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-7", "text": "// ...\n}\nA child route segment's generateStaticParams function is executed once for each segment a parent generateStaticParams generates.\nThe child generateStaticParams function can use the params returned from the parent generateStaticParams function to dynamically generate its own segments.\napp/products/[category]/[product]/page.tsx // Generate segments for [product] using the `params` passed from\n// the parent segment's `generateStaticParams` function\nexport async function generateStaticParams({\n  params: { category },\n}: {\n  params: { category: string }\n}) {\n  const products = await fetch(\n    `https://.../products?category=${category}`\n  ).then((res) => res.json())\n \n  return products.map((product) => ({\n    product: product.id,\n  }))\n}\n \nexport default function Page({\n  params,\n}: {", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "6ea27c9f4feb-8", "text": "}))\n}\n \nexport default function Page({\n  params,\n}: {\n  params: { category: string; product: string }\n}) {\n  // ...\n}\nGood to know: When rendering a route, Next.js will automatically deduplicate fetch requests for the same data across generateMetadata, generateStaticParams, Layouts, Pages, and Server Components. React cache can be used if fetch is unavailable.\nVersion History\nVersionChangesv13.0.0generateStaticParams introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/generate-static-params"}
{"id": "b4a14755a81b-0", "text": "headersThe headers function allows you to read the HTTP incoming request headers from a Server Component.\nheaders()\nThis API extends the Web Headers API. It is read-only, meaning you cannot set / delete the outgoing request headers.\napp/page.tsx import { headers } from 'next/headers'\n \nexport default function Page() {\n  const headersList = headers()\n  const referer = headersList.get('referer')\n \n  return <div>Referer: {referer}</div>\n}\nGood to know:\nheaders() is a Dynamic Function whose returned values cannot be known ahead of time. Using it in a layout or page will opt a route into dynamic rendering at request time.\nAPI Reference\n const headersList = headers()\nParameters\nheaders does not take any parameters.\nReturns\nheaders returns a read-only Web Headers object.\nHeaders.entries(): Returns an iterator allowing to go through all key/value pairs contained in this object.", "source": "https://nextjs.org/docs/app/api-reference/functions/headers"}
{"id": "b4a14755a81b-1", "text": "Headers.entries(): Returns an iterator allowing to go through all key/value pairs contained in this object.\nHeaders.forEach(): Executes a provided function once for each key/value pair in this Headers object.\nHeaders.get(): Returns a String sequence of all the values of a header within a Headers object with a given name.\nHeaders.has(): Returns a boolean stating whether a Headers object contains a certain header.\nHeaders.keys(): Returns an iterator allowing you to go through all keys of the key/value pairs contained in this object.\nHeaders.values(): Returns an iterator allowing you to go through all values of the key/value pairs contained in this object.\nExamples\nUsage with Data Fetching\nheaders() can be used in combination with Suspense for Data Fetching.\napp/page.js import { headers } from 'next/headers'\n \nasync function getUser() {\n  const headersInstance = headers()\n  const authorization = headersInstance.get('authorization')\n  // Forward the authorization header", "source": "https://nextjs.org/docs/app/api-reference/functions/headers"}
{"id": "b4a14755a81b-2", "text": "const authorization = headersInstance.get('authorization')\n  // Forward the authorization header\n  const res = await fetch('...', {\n    headers: { authorization },\n  })\n  return res.json()\n}\n \nexport default async function UserPage() {\n  const user = await getUser()\n  return <h1>{user.name}</h1>\n}\nVersion History\nVersionChangesv13.0.0headers introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/headers"}
{"id": "9de461750099-0", "text": "ImageResponseThe ImageResponse constructor allows you to generate dynamic images using JSX and CSS. This is useful for generating social media images such as Open Graph images, Twitter cards, and more.\nThe following options are available for ImageResponse:\n import { ImageResponse } from 'next/server'\n \nnew ImageResponse(\n  element: ReactElement,\n  options: {\n    width?: number = 1200\n    height?: number = 630\n    emoji?: 'twemoji' | 'blobmoji' | 'noto' | 'openmoji' = 'twemoji',\n    fonts?: {\n      name: string,\n      data: ArrayBuffer,\n      weight: number,\n      style: 'normal' | 'italic'\n    }[]\n    debug?: boolean = false\n \n    // Options that will be passed to the HTTP response\n    status?: number = 200\n    statusText?: string", "source": "https://nextjs.org/docs/app/api-reference/functions/image-response"}
{"id": "9de461750099-1", "text": "status?: number = 200\n    statusText?: string\n    headers?: Record<string, string>\n  },\n)\nSupported CSS Properties\nPlease refer to Satori\u2019s documentation for a list of supported HTML and CSS features.\nVersion History\nVersionChangesv13.3.0ImageResponse can be imported from next/server.v13.0.0ImageResponse introduced via @vercel/og package.", "source": "https://nextjs.org/docs/app/api-reference/functions/image-response"}
{"id": "66143d2debff-0", "text": "NextRequestNextRequest extends the Web Request API with additional convenience methods.\ncookies\nRead or mutate the Set-Cookie header of the request.\nset(name, value)\nGiven a name, set a cookie with the given value on the request.\n // Given incoming request /home\n// Set a cookie to hide the banner\n// request will have a `Set-Cookie:show-banner=false;path=/home` header\nrequest.cookies.set('show-banner', 'false')\nget(name)\nGiven a cookie name, return the value of the cookie. If the cookie is not found, undefined is returned. If multiple cookies are found, the first one is returned.\n // Given incoming request /home\n// { name: 'show-banner', value: 'false', Path: '/home' }\nrequest.cookies.get('show-banner')\ngetAll()", "source": "https://nextjs.org/docs/app/api-reference/functions/next-request"}
{"id": "66143d2debff-1", "text": "request.cookies.get('show-banner')\ngetAll()\nGiven a cookie name, return the values of the cookie. If no name is given, return all cookies on the request.\n // Given incoming request /home\n// [\n//   { name: 'experiments', value: 'new-pricing-page', Path: '/home' },\n//   { name: 'experiments', value: 'winter-launch', Path: '/home' },\n// ]\nrequest.cookies.getAll('experiments')\n// Alternatively, get all cookies for the request\nrequest.cookies.getAll()\ndelete(name)\nGiven a cookie name, delete the cookie from the request.\n // Returns true for deleted, false is nothing is deleted\nrequest.cookies.delete('experiments')\nhas(name)\nGiven a cookie name, return true if the cookie exists on the request.\n // Returns true if cookie exists, false if it does not\nrequest.cookies.has('experiments')\nclear()", "source": "https://nextjs.org/docs/app/api-reference/functions/next-request"}
{"id": "66143d2debff-2", "text": "request.cookies.has('experiments')\nclear()\nRemove the Set-Cookie header from the request.\n request.cookies.clear()\nnextUrl\nExtends the native URL API with additional convenience methods, including Next.js specific properties.\n // Given a request to /home, pathname is /home\nrequest.nextUrl.pathname\n// Given a request to /home?name=lee, searchParams is { 'name': 'lee' }\nrequest.nextUrl.searchParams\nVersion History\nVersionChangesv13.0.0useSearchParams introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/next-request"}
{"id": "db80150bc65b-0", "text": "NextResponseNextResponse extends the Web Response API with additional convenience methods.\ncookies\nRead or mutate the Set-Cookie header of the response.\nset(name, value)\nGiven a name, set a cookie with the given value on the response.\n // Given incoming request /home\nlet response = NextResponse.next()\n// Set a cookie to hide the banner\nresponse.cookies.set('show-banner', 'false')\n// Response will have a `Set-Cookie:show-banner=false;path=/home` header\nreturn response\nget(name)\nGiven a cookie name, return the value of the cookie. If the cookie is not found, undefined is returned. If multiple cookies are found, the first one is returned.\n // Given incoming request /home\nlet response = NextResponse.next()\n// { name: 'show-banner', value: 'false', Path: '/home' }\nresponse.cookies.get('show-banner')\ngetAll()", "source": "https://nextjs.org/docs/app/api-reference/functions/next-response"}
{"id": "db80150bc65b-1", "text": "response.cookies.get('show-banner')\ngetAll()\nGiven a cookie name, return the values of the cookie. If no name is given, return all cookies on the response.\n // Given incoming request /home\nlet response = NextResponse.next()\n// [\n//   { name: 'experiments', value: 'new-pricing-page', Path: '/home' },\n//   { name: 'experiments', value: 'winter-launch', Path: '/home' },\n// ]\nresponse.cookies.getAll('experiments')\n// Alternatively, get all cookies for the response\nresponse.cookies.getAll()\ndelete(name)\nGiven a cookie name, delete the cookie from the response.\n // Given incoming request /home\nlet response = NextResponse.next()\n// Returns true for deleted, false is nothing is deleted\nresponse.cookies.delete('experiments')\njson()\nProduce a response with the given JSON body.", "source": "https://nextjs.org/docs/app/api-reference/functions/next-response"}
{"id": "db80150bc65b-2", "text": "json()\nProduce a response with the given JSON body.\napp/api/route.ts import { NextResponse } from 'next/server'\n \nexport async function GET(request: Request) {\n  return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 })\n}\nredirect()\nProduce a response that redirects to a URL.\n import { NextResponse } from 'next/server'\n \nreturn NextResponse.redirect(new URL('/new', request.url))\nThe URL can be created and modified before being used in the NextResponse.redirect() method. For example, you can use the request.nextUrl property to get the current URL, and then modify it to redirect to a different URL.\n import { NextResponse } from 'next/server'\n \n// Given an incoming request...\nconst loginUrl = new URL('/login', request.url)\n// Add ?from=/incoming-url to the /login URL", "source": "https://nextjs.org/docs/app/api-reference/functions/next-response"}
{"id": "db80150bc65b-3", "text": "// Add ?from=/incoming-url to the /login URL\nloginUrl.searchParams.set('from', request.nextUrl.pathname)\n// And redirect to the new URL\nreturn NextResponse.redirect(loginUrl)\nrewrite()\nProduce a response that rewrites (proxies) the given URL while preserving the original URL.\n import { NextResponse } from 'next/server'\n \n// Incoming request: /about, browser shows /about\n// Rewritten request: /proxy, browser shows /about\nreturn NextResponse.rewrite(new URL('/proxy', request.url))\nnext()\nThe next() method is useful for Middleware, as it allows you to return early and continue routing.\n import { NextResponse } from 'next/server'\n \nreturn NextResponse.next()\nYou can also forward headers when producing the response:\n import { NextResponse } from 'next/server'\n \n// Given an incoming request...", "source": "https://nextjs.org/docs/app/api-reference/functions/next-response"}
{"id": "db80150bc65b-4", "text": "import { NextResponse } from 'next/server'\n \n// Given an incoming request...\nconst newHeaders = new Headers(request.headers)\n// Add a new header\nnewHeaders.set('x-version', '123')\n// And produce a response with the new headers\nreturn NextResponse.next({\n  request: {\n    // New request headers\n    headers: newHeaders,\n  },\n})", "source": "https://nextjs.org/docs/app/api-reference/functions/next-response"}
{"id": "9eeda12cf0af-0", "text": "notFoundThe notFound function allows you to render the not-found file within a route segment as well as inject a <meta name=\"robots\" content=\"noindex\" /> tag.\nnotFound()\nInvoking the notFound() function throws a NEXT_NOT_FOUND error and terminates rendering of the route segment in which it was thrown. Specifying a not-found file allows you to gracefully handle such errors by rendering a Not Found UI within the segment.\napp/user/[id]/page.js import { notFound } from 'next/navigation'\n \nasync function fetchUser(id) {\n  const res = await fetch('https://...')\n  if (!res.ok) return undefined\n  return res.json()\n}\n \nexport default async function Profile({ params }) {\n  const user = await fetchUser(params.id)\n \n  if (!user) {\n    notFound()\n  }\n \n  // ...\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/not-found"}
{"id": "9eeda12cf0af-1", "text": "notFound()\n  }\n \n  // ...\n}\nGood to know: notFound() does not require you to use return notFound() due to using the TypeScript never type.\nVersion History\nVersionChangesv13.0.0notFound introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/not-found"}
{"id": "eb3aba3a1e25-0", "text": "redirectThe redirect function allows you to redirect the user to another URL. redirect can be used in Server Components, Client Components, Route Handlers, and Server Actions.\nIf you need to redirect to a 404, use the notFound function instead.\nParameters\nThe redirect function accepts two arguments:\n redirect(path, type)\nParameterTypeDescriptionpathstringThe URL to redirect to. Can be a relative or absolute path.type'replace' (default) or 'push' (default in Server Actions)The type of redirect to perform.\nBy default, redirect will use push (adding a new entry to the browser history stack) in Server Actions) and replace (replacing the current URL in the browser history stack) everywhere else. You can override this behavior by specifying the type parameter.\nThe type parameter has no effect when used in Server Components.\nReturns\nredirect does not return any value.\nExample", "source": "https://nextjs.org/docs/app/api-reference/functions/redirect"}
{"id": "eb3aba3a1e25-1", "text": "Returns\nredirect does not return any value.\nExample\nInvoking the redirect() function throws a NEXT_REDIRECT error and terminates rendering of the route segment in which it was thrown.\napp/team/[id]/page.js import { redirect } from 'next/navigation'\n \nasync function fetchTeam(id) {\n  const res = await fetch('https://...')\n  if (!res.ok) return undefined\n  return res.json()\n}\n \nexport default async function Profile({ params }) {\n  const team = await fetchTeam(params.id)\n  if (!team) {\n    redirect('/login')\n  }\n \n  // ...\n}\nGood to know: redirect does not require you to use return redirect() as it uses the TypeScript never type.\nVersionChangesv13.0.0redirect introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/redirect"}
{"id": "ea4d089e49b4-0", "text": "revalidatePathrevalidatePath allows you to revalidate data associated with a specific path. This is useful for scenarios where you want to update your cached data without waiting for a revalidation period to expire.\napp/api/revalidate/route.ts import { NextRequest, NextResponse } from 'next/server'\nimport { revalidatePath } from 'next/cache'\n \nexport async function GET(request: NextRequest) {\n  const path = request.nextUrl.searchParams.get('path') || '/'\n  revalidatePath(path)\n  return NextResponse.json({ revalidated: true, now: Date.now() })\n}\nGood to know:\nrevalidatePath is available in both Node.js and Edge runtimes.", "source": "https://nextjs.org/docs/app/api-reference/functions/revalidatePath"}
{"id": "ea4d089e49b4-1", "text": "Good to know:\nrevalidatePath is available in both Node.js and Edge runtimes.\nrevalidatePath will revalidate all segments under a dynamic route segment. For example, if you have a dynamic segment /product/[id] and you call revalidatePath('/product/[id]'), then all segments under /product/[id] will be revalidated as requested.\nrevalidatePath only invalidates the cache when the path is next visited. This means calling revalidatePath with a dynamic route segment will not immediately trigger many revalidations at once. The invalidation only happens when the path is next visited.\nParameters\n revalidatePath(path: string): void;\npath: A string representing the filesystem path associated with the data you want to revalidate. This is not the literal route segment (e.g. /product/123) but instead the path on the filesystem (e.g. /product/[id]).\nReturns", "source": "https://nextjs.org/docs/app/api-reference/functions/revalidatePath"}
{"id": "ea4d089e49b4-2", "text": "Returns\nrevalidatePath does not return any value.\nExamples\nNode.js Runtime\napp/api/revalidate/route.ts import { NextRequest, NextResponse } from 'next/server'\nimport { revalidatePath } from 'next/cache'\n \nexport async function GET(request: NextRequest) {\n  const path = request.nextUrl.searchParams.get('path') || '/'\n  revalidatePath(path)\n  return NextResponse.json({ revalidated: true, now: Date.now() })\n}\nEdge Runtime\napp/api/revalidate/route.ts import { NextRequest, NextResponse } from 'next/server'\nimport { revalidatePath } from 'next/cache'\n \nexport const runtime = 'edge'\n \nexport async function GET(request: NextRequest) {\n  const path = request.nextUrl.searchParams.get('path') || '/'\n  revalidatePath(path)", "source": "https://nextjs.org/docs/app/api-reference/functions/revalidatePath"}
{"id": "ea4d089e49b4-3", "text": "revalidatePath(path)\n  return NextResponse.json({ revalidated: true, now: Date.now() })\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/revalidatePath"}
{"id": "84313f942a21-0", "text": "revalidateTagrevalidateTag allows you to revalidate data associated with a specific cache tag. This is useful for scenarios where you want to update your cached data without waiting for a revalidation period to expire.\napp/api/revalidate/route.ts import { NextRequest, NextResponse } from 'next/server'\nimport { revalidateTag } from 'next/cache'\n \nexport async function GET(request: NextRequest) {\n  const tag = request.nextUrl.searchParams.get('tag')\n  revalidateTag(tag)\n  return NextResponse.json({ revalidated: true, now: Date.now() })\n}\nGood to know:\nrevalidateTag is available in both Node.js and Edge runtimes.\nParameters\n revalidateTag(tag: string): void;\ntag: A string representing the cache tag associated with the data you want to revalidate.\nYou can add tags to fetch as follows:", "source": "https://nextjs.org/docs/app/api-reference/functions/revalidateTag"}
{"id": "84313f942a21-1", "text": "You can add tags to fetch as follows:\n fetch(url, { next: { tags: [...] } });\nReturns\nrevalidateTag does not return any value.\nExamples\nNode.js Runtime\napp/api/revalidate/route.ts import { NextRequest, NextResponse } from 'next/server'\nimport { revalidateTag } from 'next/cache'\n \nexport async function GET(request: NextRequest) {\n  const tag = request.nextUrl.searchParams.get('tag')\n  revalidateTag(tag)\n  return NextResponse.json({ revalidated: true, now: Date.now() })\n}\nEdge Runtime\napp/api/revalidate/route.ts import { NextRequest, NextResponse } from 'next/server'\nimport { revalidateTag } from 'next/cache'\n \nexport const runtime = 'edge'\n \nexport async function GET(request: NextRequest) {", "source": "https://nextjs.org/docs/app/api-reference/functions/revalidateTag"}
{"id": "84313f942a21-2", "text": "export async function GET(request: NextRequest) {\n  const tag = request.nextUrl.searchParams.get('tag')\n  revalidateTag(tag)\n  return NextResponse.json({ revalidated: true, now: Date.now() })\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/revalidateTag"}
{"id": "cb9ff5bbd24c-0", "text": "useParamsuseParams is a Client Component hook that lets you read a route's dynamic params filled in by the current URL.\napp/example-client-component.tsx 'use client'\n \nimport { useParams } from 'next/navigation'\n \nexport default function ExampleClientComponent() {\n  const params = useParams()\n \n  // Route -> /shop/[tag]/[item]\n  // URL -> /shop/shoes/nike-air-max-97\n  // `params` -> { tag: 'shoes', item: 'nike-air-max-97' }\n  console.log(params)\n \n  return <></>\n}\nParameters\n const params = useParams()\nuseParams does not take any parameters.\nReturns\nuseParams returns an object containing the current route's filled in dynamic parameters.\nEach property in the object is an active dynamic segment.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-params"}
{"id": "cb9ff5bbd24c-1", "text": "Each property in the object is an active dynamic segment.\nThe properties name is the segment's name, and the properties value is what the segment is filled in with.\nThe properties value will either be a string or array of string's depending on the type of dynamic segment.\nIf the route contains no dynamic parameters, useParams returns an empty object.\nIf used in pages, useParams will return null.\nFor example:\nRouteURLuseParams()app/shop/page.js/shopnullapp/shop/[slug]/page.js/shop/1{ slug: '1' }app/shop/[tag]/[item]/page.js/shop/1/2{ tag: '1', item: '2' }app/shop/[...slug]/page.js/shop/1/2{ slug: ['1', '2'] }\nVersion History\nVersionChangesv13.3.0useParams introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-params"}
{"id": "9085570e8c89-0", "text": "usePathnameusePathname is a Client Component hook that lets you read the current URL's pathname.\napp/example-client-component.tsx 'use client'\n \nimport { usePathname } from 'next/navigation'\n \nexport default function ExampleClientComponent() {\n  const pathname = usePathname()\n  return <p>Current pathname: {pathname}</p>\n}\nusePathname intentionally requires using a Client Component. It's important to note Client Components are not a de-optimization. They are an integral part of the Server Components architecture.\nFor example, a Client Component with usePathname will be rendered into HTML on the initial page load. When navigating to a new route, this component does not need to be re-fetched. Instead, the component is downloaded once (in the client JavaScript bundle), and re-renders based on the current state.\nGood to know:", "source": "https://nextjs.org/docs/app/api-reference/functions/use-pathname"}
{"id": "9085570e8c89-1", "text": "Good to know:\nReading the current URL from a Server Component is not supported. This design is intentional to support layout state being preserved across page navigations.\nCompatibility mode:\nusePathname can return null when a fallback route is being rendered or when a pages directory page has been automatically statically optimized by Next.js and the router is not ready.\nNext.js will automatically update your types if it detects both an app and pages directory in your project.\nParameters\n const pathname = usePathname()\nusePathname does not take any parameters.\nReturns\nusePathname returns a string of the current URL's pathname. For example:\nURLReturned value/'/'/dashboard'/dashboard'/dashboard?v=2'/dashboard'/blog/hello-world'/blog/hello-world'\nExamples\nDo something in response to a route change\napp/example-client-component.tsx 'use client'\n \nimport { usePathname, useSearchParams } from 'next/navigation'", "source": "https://nextjs.org/docs/app/api-reference/functions/use-pathname"}
{"id": "9085570e8c89-2", "text": "import { usePathname, useSearchParams } from 'next/navigation'\n \nfunction ExampleClientComponent() {\n  const pathname = usePathname()\n  const searchParams = useSearchParams()\n  useEffect(() => {\n    // Do something here...\n  }, [pathname, searchParams])\n}\nVersionChangesv13.0.0usePathname introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-pathname"}
{"id": "486dbdce1797-0", "text": "useReportWebVitals\nThe useReportWebVitals hook allows you to report Core Web Vitals, and can be used in combination with your analytics service.\napp/_components/web-vitals.js 'use client'\n \nimport { useReportWebVitals } from 'next/web-vitals'\n \nexport function WebVitals() {\n  useReportWebVitals((metric) => {\n    console.log(metric)\n  })\n}app/layout.js import { WebVitals } from './_components/web-vitals'\n \nexport default function Layout({ children }) {\n  return (\n    <html>\n      <body>\n        <WebVitals />\n        {children}\n      </body>\n    </html>\n  )\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/use-report-web-vitals"}
{"id": "486dbdce1797-1", "text": "{children}\n      </body>\n    </html>\n  )\n}\nSince the useReportWebVitals hook requires the \"use client\" directive, the most performant approach is to create a separate component that the root layout imports. This confines the client boundary exclusively to the WebVitals component.\nuseReportWebVitals\nThe metric object passed as the hook's argument consists of a number of properties:\nid: Unique identifier for the metric in the context of the current page load\nname: The name of the performance metric. Possible values include names of Web Vitals metrics (TTFB, FCP, LCP, FID, CLS) specific to a web application.\ndelta: The difference between the current value and the previous value of the metric. The value is typically in milliseconds and represents the change in the metric's value over time.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-report-web-vitals"}
{"id": "486dbdce1797-2", "text": "entries: An array of Performance Entries associated with the metric. These entries provide detailed information about the performance events related to the metric.\nnavigationType: Indicates the type of navigation that triggered the metric collection. Possible values include \"navigate\", \"reload\", \"back_forward\", and \"prerender\".\nrating: A qualitative rating of the metric value, providing an assessment of the performance. Possible values are \"good\", \"needs-improvement\", and \"poor\". The rating is typically determined by comparing the metric value against predefined thresholds that indicate acceptable or suboptimal performance.\nvalue: The actual value or duration of the performance entry, typically in milliseconds. The value provides a quantitative measure of the performance aspect being tracked by the metric. The source of the value depends on the specific metric being measured and can come from various Performance APIs.\nWeb Vitals\nWeb Vitals are a set of useful metrics that aim to capture the user", "source": "https://nextjs.org/docs/app/api-reference/functions/use-report-web-vitals"}
{"id": "486dbdce1797-3", "text": "Web Vitals\nWeb Vitals are a set of useful metrics that aim to capture the user\nexperience of a web page. The following web vitals are all included:\nTime to First Byte (TTFB)\nFirst Contentful Paint (FCP)\nLargest Contentful Paint (LCP)\nFirst Input Delay (FID)\nCumulative Layout Shift (CLS)\nInteraction to Next Paint (INP)\nYou can handle all the results of these metrics using the name property.\napp/components/web-vitals.tsx 'use client'\n \nimport { useReportWebVitals } from 'next/web-vitals'\n \nexport function WebVitals() {\n  useReportWebVitals((metric) => {\n    switch (metric.name) {\n      case 'FCP': {\n        // handle FCP results\n      }\n      case 'LCP': {\n        // handle LCP results", "source": "https://nextjs.org/docs/app/api-reference/functions/use-report-web-vitals"}
{"id": "486dbdce1797-4", "text": "}\n      case 'LCP': {\n        // handle LCP results\n      }\n      // ...\n    }\n  })\n}\nUsage on Vercel\nVercel Speed Insights are automatically configured on Vercel deployments, and don't require the use of useReportWebVitals. This hook is useful in local development, or if you're using a different analytics service.\nSending results to external systems\nYou can send results to any endpoint to measure and track\nreal user performance on your site. For example:\n useReportWebVitals((metric) => {\n  const body = JSON.stringify(metric)\n  const url = 'https://example.com/analytics'\n \n  // Use `navigator.sendBeacon()` if available, falling back to `fetch()`.\n  if (navigator.sendBeacon) {\n    navigator.sendBeacon(url, body)\n  } else {", "source": "https://nextjs.org/docs/app/api-reference/functions/use-report-web-vitals"}
{"id": "486dbdce1797-5", "text": "navigator.sendBeacon(url, body)\n  } else {\n    fetch(url, { body, method: 'POST', keepalive: true })\n  }\n})\nGood to know: If you use Google Analytics, using the\nid value can allow you to construct metric distributions manually (to calculate percentiles,\netc.)\n useReportWebVitals(metric => {\n  // Use `window.gtag` if you initialized Google Analytics as this example:\n  // https://github.com/vercel/next.js/blob/canary/examples/with-google-analytics/pages/_app.js\n  window.gtag('event', metric.name, {\n    value: Math.round(metric.name === 'CLS' ? metric.value * 1000 : metric.value), // values must be integers\n    event_label: metric.id, // id unique to current page load\n    non_interaction: true, // avoids affecting bounce rate.\n  });\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/use-report-web-vitals"}
{"id": "486dbdce1797-6", "text": "non_interaction: true, // avoids affecting bounce rate.\n  });\n}\nRead more about sending results to Google Analytics.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-report-web-vitals"}
{"id": "a32e123ba449-0", "text": "useRouterThe useRouter hook allows you to programmatically change routes inside Client Components.\nRecommendation: Use the <Link> component for navigation unless you have a specific requirement for using useRouter.\napp/example-client-component.tsx 'use client'\n \nimport { useRouter } from 'next/navigation'\n \nexport default function Page() {\n  const router = useRouter()\n \n  return (\n    <button type=\"button\" onClick={() => router.push('/dashboard')}>\n      Dashboard\n    </button>\n  )\n}\nuseRouter()\nrouter.push(href: string): Perform a client-side navigation to the provided route. Adds a new entry into the browser\u2019s history stack.\nrouter.replace(href: string): Perform a client-side navigation to the provided route without adding a new entry into the browser\u2019s history stack.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-router"}
{"id": "a32e123ba449-1", "text": "router.refresh(): Refresh the current route. Making a new request to the server, re-fetching data requests, and re-rendering Server Components. The client will merge the updated React Server Component payload without losing unaffected client-side React (e.g. useState) or browser state (e.g. scroll position).\nrouter.prefetch(href: string): Prefetch the provided route for faster client-side transitions.\nrouter.back(): Navigate back to the previous route in the browser\u2019s history stack using soft navigation.\nrouter.forward(): Navigate forwards to the next page in the browser\u2019s history stack using soft navigation.\nGood to know:\nThe push() and replace() methods will perform a soft navigation if the new route has been prefetched, and either, doesn't include dynamic segments or has the same dynamic parameters as the current route.\nnext/link automatically prefetch routes as they become visible in the viewport.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-router"}
{"id": "a32e123ba449-2", "text": "next/link automatically prefetch routes as they become visible in the viewport.\nrefresh() could re-produce the same result if fetch requests are cached. Other dynamic functions like cookies and headers could also change the response.\nMigrating from the pages directory:\nThe new useRouter hook should be imported from next/navigation and not next/router\nThe pathname string has been removed and is replaced by usePathname()\nThe query object has been removed and is replaced by useSearchParams()\nrouter.events is not currently supported. See below.\nView the full migration guide.\nExamples\nRouter Events\nYou can listen for page changes by composing other Client Component hooks like usePathname and useSearchParams.\napp/components/navigation-events.js 'use client'\n \nimport { useEffect } from 'react'\nimport { usePathname, useSearchParams } from 'next/navigation'\n \nexport function NavigationEvents() {\n  const pathname = usePathname()", "source": "https://nextjs.org/docs/app/api-reference/functions/use-router"}
{"id": "a32e123ba449-3", "text": "export function NavigationEvents() {\n  const pathname = usePathname()\n  const searchParams = useSearchParams()\n \n  useEffect(() => {\n    const url = `${pathname}?${searchParams}`\n    console.log(url)\n    // You can now use the current URL\n    // ...\n  }, [pathname, searchParams])\n \n  return null\n}\nWhich can be imported into a layout.\napp/layout.js import { Suspense } from 'react'\nimport { NavigationEvents } from './components/navigation-events'\n \nexport default function Layout({ children }) {\n  return (\n    <html lang=\"en\">\n      <body>\n        {children}\n \n        <Suspense fallback={null}>\n          <NavigationEvents />\n        </Suspense>\n      </body>\n    </html>\n  )\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/use-router"}
{"id": "a32e123ba449-4", "text": "</body>\n    </html>\n  )\n}\nGood to know: <NavigationEvents> is wrapped in a Suspense boundary becauseuseSearchParams() causes client-side rendering up to the closest Suspense boundary during static rendering. Learn more.\nVersionChangesv13.0.0useRouter from next/navigation introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-router"}
{"id": "69e77b6c1730-0", "text": "useSearchParamsuseSearchParams is a Client Component hook that lets you read the current URL's query string.\nuseSearchParams returns a read-only version of the URLSearchParams interface.\napp/dashboard/search-bar.tsx 'use client'\n \nimport { useSearchParams } from 'next/navigation'\n \nexport default function SearchBar() {\n  const searchParams = useSearchParams()\n \n  const search = searchParams.get('search')\n \n  // URL -> `/dashboard?search=my-project`\n  // `search` -> 'my-project'\n  return <>Search: {search}</>\n}\nParameters\n const searchParams = useSearchParams()\nuseSearchParams does not take any parameters.\nReturns\nuseSearchParams returns a read-only version of the URLSearchParams interface, which includes utility methods for reading the URL's query string:\nURLSearchParams.get(): Returns the first value associated with the search parameter. For example:", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "69e77b6c1730-1", "text": "URLSearchParams.get(): Returns the first value associated with the search parameter. For example:\nURLsearchParams.get(\"a\")/dashboard?a=1'1'/dashboard?a=''/dashboard?b=3null/dashboard?a=1&a=2'1' - use getAll() to get all values\nURLSearchParams.has(): Returns a boolean value indicating if the given parameter exists. For example:\nURLsearchParams.has(\"a\")/dashboard?a=1true/dashboard?b=3false\nLearn more about other read-only methods of URLSearchParams, including the getAll(), keys(), values(), entries(), forEach(), and toString().\nGood to know:\nuseSearchParams is a Client Component hook and is not supported in Server Components to prevent stale values during partial rendering.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "69e77b6c1730-2", "text": "If an application includes the /pages directory, useSearchParams will return ReadonlyURLSearchParams | null. The null value is for compatibility during migration since search params cannot be known during pre-rendering of a page that doesn't use getServerSideProps\nBehavior\nStatic Rendering\nIf a route is statically rendered, calling useSearchParams() will cause the tree up to the closest Suspense boundary to be client-side rendered.\nThis allows a part of the page to be statically rendered while the dynamic part that uses searchParams is client-side rendered.\nYou can reduce the portion of the route that is client-side rendered by wrapping the component that uses useSearchParams in a Suspense boundary. For example:\napp/dashboard/search-bar.tsx 'use client'\n \nimport { useSearchParams } from 'next/navigation'\n \nexport default function SearchBar() {\n  const searchParams = useSearchParams()\n \n  const search = searchParams.get('search')", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "69e77b6c1730-3", "text": "const search = searchParams.get('search')\n \n  // This will not be logged on the server when using static rendering\n  console.log(search)\n \n  return <>Search: {search}</>\n}\napp/dashboard/page.tsx import { Suspense } from 'react'\nimport SearchBar from './search-bar'\n \n// This component passed as a fallback to the Suspense boundary\n// will be rendered in place of the search bar in the initial HTML.\n// When the value is available during React hydration the fallback\n// will be replaced with the `<SearchBar>` component.\nfunction SearchBarFallback() {\n  return <>placeholder</>\n}\n \nexport default function Page() {\n  return (\n    <>\n      <nav>\n        <Suspense fallback={<SearchBarFallback />}>\n          <SearchBar />\n        </Suspense>\n      </nav>", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "69e77b6c1730-4", "text": "<SearchBar />\n        </Suspense>\n      </nav>\n      <h1>Dashboard</h1>\n    </>\n  )\n}\nDynamic Rendering\nIf a route is dynamically rendered, useSearchParams will be available on the server during the initial server render of the Client Component.\nGood to know: Setting the dynamic route segment config option to force-dynamic can be used to force dynamic rendering.\nFor example:\napp/dashboard/search-bar.tsx 'use client'\n \nimport { useSearchParams } from 'next/navigation'\n \nexport default function SearchBar() {\n  const searchParams = useSearchParams()\n \n  const search = searchParams.get('search')\n \n  // This will be logged on the server during the initial render\n  // and on the client on subsequent navigations.\n  console.log(search)\n \n  return <>Search: {search}</>\n}", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "69e77b6c1730-5", "text": "console.log(search)\n \n  return <>Search: {search}</>\n}\napp/dashboard/page.tsx import SearchBar from './search-bar'\n \nexport const dynamic = 'force-dynamic'\n \nexport default function Page() {\n  return (\n    <>\n      <nav>\n        <SearchBar />\n      </nav>\n      <h1>Dashboard</h1>\n    </>\n  )\n}\nServer Components\nPages\nTo access search params in Pages (Server Components), use the searchParams prop.\nLayouts\nUnlike Pages, Layouts (Server Components) do not receive the searchParams prop. This is because a shared layout is not re-rendered during navigation which could lead to stale searchParams between navigations. View detailed explanation.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "69e77b6c1730-6", "text": "Instead, use the Page searchParams prop or the useSearchParams hook in a Client Component, which is re-rendered on the client with the latest searchParams.\nExamples\nUpdating searchParams\nYou can use useRouter or Link to set new searchParams. After a navigation is performed, the current page.js will receive an updated searchParams prop.\napp/example-client-component.tsx export default function ExampleClientComponent() {\n  const router = useRouter()\n  const pathname = usePathname()\n  const searchParams = useSearchParams()!\n \n  // Get a new searchParams string by merging the current\n  // searchParams with a provided key/value pair\n  const createQueryString = useCallback(\n    (name: string, value: string) => {\n      const params = new URLSearchParams(searchParams)\n      params.set(name, value)\n \n      return params.toString()\n    },\n    [searchParams]\n  )", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "69e77b6c1730-7", "text": "return params.toString()\n    },\n    [searchParams]\n  )\n \n  return (\n    <>\n      <p>Sort By</p>\n \n      {/* using useRouter */}\n      <button\n        onClick={() => {\n          // <pathname>?sort=asc\n          router.push(pathname + '?' + createQueryString('sort', 'asc'))\n        }}\n      >\n        ASC\n      </button>\n \n      {/* using <Link> */}\n      <Link\n        href={\n          // <pathname>?sort=desc\n          pathname + '?' + createQueryString('sort', 'desc')\n        }\n      >\n        DESC\n      </Link>\n    </>\n  )\n}\nVersion History\nVersionChangesv13.0.0useSearchParams introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-search-params"}
{"id": "1d47e4b5cb53-0", "text": "useSelectedLayoutSegmentuseSelectedLayoutSegment is a Client Component hook that lets you read the active route segment one level below the Layout it is called from.\nIt is useful for navigation UI, such as tabs inside a parent layout that change style depending on the active child segment.\napp/example-client-component.tsx 'use client'\n \nimport { useSelectedLayoutSegment } from 'next/navigation'\n \nexport default function ExampleClientComponent() {\n  const segment = useSelectedLayoutSegment()\n \n  return <p>Active segment: {segment}</p>\n}\nGood to know:\nSince useSelectedLayoutSegment is a Client Component hook, and Layouts are Server Components by default, useSelectedLayoutSegment is usually called via a Client Component that is imported into a Layout.\nuseSelectedLayoutSegment only returns the segment one level down. To return all active segments, see useSelectedLayoutSegments\nParameters\n const segment = useSelectedLayoutSegment()", "source": "https://nextjs.org/docs/app/api-reference/functions/use-selected-layout-segment"}
{"id": "1d47e4b5cb53-1", "text": "Parameters\n const segment = useSelectedLayoutSegment()\nuseSelectedLayoutSegment does not take any parameters.\nReturns\nuseSelectedLayoutSegment returns a string of the active segment or null if one doesn't exist.\nFor example, given the Layouts and URLs below, the returned segment would be:\nLayoutVisited URLReturned Segmentapp/layout.js/nullapp/layout.js/dashboard'dashboard'app/dashboard/layout.js/dashboardnullapp/dashboard/layout.js/dashboard/settings'settings'app/dashboard/layout.js/dashboard/analytics'analytics'app/dashboard/layout.js/dashboard/analytics/monthly'analytics'\nExamples\nCreating an active link component\nYou can use useSelectedLayoutSegment to create an active link component that changes style depending on the active segment. For example, a featured posts list in the sidebar of a blog:\napp/blog/blog-nav-link.tsx 'use client'\n \nimport Link from 'next/link'\nimport { useSelectedLayoutSegment } from 'next/navigation'", "source": "https://nextjs.org/docs/app/api-reference/functions/use-selected-layout-segment"}
{"id": "1d47e4b5cb53-2", "text": "import { useSelectedLayoutSegment } from 'next/navigation'\n \n// This *client* component will be imported into a blog layout\nexport default function BlogNavLink({\n  slug,\n  children,\n}: {\n  slug: string\n  children: React.ReactNode\n}) {\n  // Navigating to `/blog/hello-world` will return 'hello-world'\n  // for the selected layout segment\n  const segment = useSelectedLayoutSegment()\n  const isActive = slug === segment\n \n  return (\n    <Link\n      href={`/blog/${slug}`}\n      // Change style depending on whether the link is active\n      style={{ fontWeight: isActive ? 'bold' : 'normal' }}\n    >\n      {children}\n    </Link>\n  )\n}\napp/blog/layout.tsx // Import the Client Component into a parent Layout (Server Component)", "source": "https://nextjs.org/docs/app/api-reference/functions/use-selected-layout-segment"}
{"id": "1d47e4b5cb53-3", "text": "app/blog/layout.tsx // Import the Client Component into a parent Layout (Server Component)\nimport { BlogNavLink } from './blog-nav-link'\nimport getFeaturedPosts from './get-featured-posts'\n \nexport default async function Layout({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  const featuredPosts = await getFeaturedPosts()\n  return (\n    <div>\n      {featuredPosts.map((post) => (\n        <div key={post.id}>\n          <BlogNavLink slug={post.slug}>{post.title}</BlogNavLink>\n        </div>\n      ))}\n      <div>{children}</div>\n    </div>\n  )\n}\nVersion History\nVersionChangesv13.0.0useSelectedLayoutSegment introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-selected-layout-segment"}
{"id": "75b763a886ee-0", "text": "useSelectedLayoutSegmentsuseSelectedLayoutSegments is a Client Component hook that lets you read the active route segments below the Layout it is called from.\nIt is useful for creating UI in parent Layouts that need knowledge of active child segments such as breadcrumbs.\napp/example-client-component.tsx 'use client'\n \nimport { useSelectedLayoutSegments } from 'next/navigation'\n \nexport default function ExampleClientComponent() {\n  const segments = useSelectedLayoutSegments()\n \n  return (\n    <ul>\n      {segments.map((segment, index) => (\n        <li key={index}>{segment}</li>\n      ))}\n    </ul>\n  )\n}\nGood to know:\nSince useSelectedLayoutSegments is a Client Component hook, and Layouts are Server Components by default, useSelectedLayoutSegments is usually called via a Client Component that is imported into a Layout.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-selected-layout-segments"}
{"id": "75b763a886ee-1", "text": "The returned segments include Route Groups, which you might not want to be included in your UI. You can use the filter() array method to remove items that start with a bracket.\nParameters\n const segments = useSelectedLayoutSegments()\nuseSelectedLayoutSegments does not take any parameters.\nReturns\nuseSelectedLayoutSegments returns an array of strings containing the active segments one level down from the layout the hook was called from. Or an empty array if none exist.\nFor example, given the Layouts and URLs below, the returned segments would be:\nLayoutVisited URLReturned Segmentsapp/layout.js/[]app/layout.js/dashboard['dashboard']app/layout.js/dashboard/settings['dashboard', 'settings']app/dashboard/layout.js/dashboard[]app/dashboard/layout.js/dashboard/settings['settings']\nVersion History\nVersionChangesv13.0.0useSelectedLayoutSegments introduced.", "source": "https://nextjs.org/docs/app/api-reference/functions/use-selected-layout-segments"}
{"id": "f93830721c3d-0", "text": "appDir\nGood to know: This option is no longer needed as of Next.js 13.4. The App Router is now stable.\nThe App Router (app directory) enables support for layouts, Server Components, streaming, and colocated data fetching.\nUsing the app directory will automatically enable React Strict Mode. Learn how to incrementally adopt app.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/appDir"}
{"id": "0f1453ba6c2e-0", "text": "assetPrefix\nAttention: Deploying to Vercel automatically configures a global CDN for your Next.js project.\nYou do not need to manually setup an Asset Prefix.\nGood to know: Next.js 9.5+ added support for a customizable Base Path, which is better\nsuited for hosting your application on a sub-path like /docs.\nWe do not suggest you use a custom Asset Prefix for this use case.\nTo set up a CDN, you can set up an asset prefix and configure your CDN's origin to resolve to the domain that Next.js is hosted on.\nOpen next.config.js and add the assetPrefix config:\nnext.config.js const isProd = process.env.NODE_ENV === 'production'\n \nmodule.exports = {\n  // Use the CDN in production and localhost for development.\n  assetPrefix: isProd ? 'https://cdn.mydomain.com' : undefined,\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/assetPrefix"}
{"id": "0f1453ba6c2e-1", "text": "}\nNext.js will automatically use your asset prefix for the JavaScript and CSS files it loads from the /_next/ path (.next/static/ folder). For example, with the above configuration, the following request for a JS chunk:\n /_next/static/chunks/4b9b41aaa062cbbfeff4add70f256968c51ece5d.4d708494b3aed70c04f0.js\nWould instead become:\n https://cdn.mydomain.com/_next/static/chunks/4b9b41aaa062cbbfeff4add70f256968c51ece5d.4d708494b3aed70c04f0.js", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/assetPrefix"}
{"id": "0f1453ba6c2e-2", "text": "The exact configuration for uploading your files to a given CDN will depend on your CDN of choice. The only folder you need to host on your CDN is the contents of .next/static/, which should be uploaded as _next/static/ as the above URL request indicates. Do not upload the rest of your .next/ folder, as you should not expose your server code and other configuration to the public.\nWhile assetPrefix covers requests to _next/static, it does not influence the following paths:\nFiles in the public folder; if you want to serve those assets over a CDN, you'll have to introduce the prefix yourself", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/assetPrefix"}
{"id": "254abb17941d-0", "text": "basePath\nTo deploy a Next.js application under a sub-path of a domain you can use the basePath config option.\nbasePath allows you to set a path prefix for the application. For example, to use /docs instead of '' (an empty string, the default), open next.config.js and add the basePath config:\nnext.config.js module.exports = {\n  basePath: '/docs',\n}\nGood to know: This value must be set at build time and cannot be changed without re-building as the value is inlined in the client-side bundles.\nLinks\nWhen linking to other pages using next/link and next/router the basePath will be automatically applied.\nFor example, using /about will automatically become /docs/about when basePath is set to /docs.\n export default function HomePage() {\n  return (\n    <>\n      <Link href=\"/about\">About Page</Link>\n    </>\n  )\n}\nOutput html:", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/basePath"}
{"id": "254abb17941d-1", "text": "</>\n  )\n}\nOutput html:\n <a href=\"/docs/about\">About Page</a>\nThis makes sure that you don't have to change all links in your application when changing the basePath value.\nImages\nWhen using the next/image component, you will need to add the basePath in front of src.\nFor example, using /docs/me.png will properly serve your image when basePath is set to /docs.\n import Image from 'next/image'\n \nfunction Home() {\n  return (\n    <>\n      <h1>My Homepage</h1>\n      <Image\n        src=\"/docs/me.png\"\n        alt=\"Picture of the author\"\n        width={500}\n        height={500}\n      />\n      <p>Welcome to my homepage!</p>\n    </>\n  )\n}\n \nexport default Home", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/basePath"}
{"id": "427c3679ff87-0", "text": "compress\nNext.js provides gzip compression to compress rendered content and static files. In general you will want to enable compression on a HTTP proxy like nginx, to offload load from the Node.js process.\nTo disable compression, open next.config.js and disable the compress config:\nnext.config.js module.exports = {\n  compress: false,\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/compress"}
{"id": "709f6ebe1430-0", "text": "devIndicators\nWhen you edit your code, and Next.js is compiling the application, a compilation indicator appears in the bottom right corner of the page.\nGood to know: This indicator is only present in development mode and will not appear when building and running the app in production mode.\nIn some cases this indicator can be misplaced on your page, for example, when conflicting with a chat launcher. To change its position, open next.config.js and set the buildActivityPosition in the devIndicators object to bottom-right (default), bottom-left, top-right or top-left:next.config.js module.exports = {\n  devIndicators: {\n    buildActivityPosition: 'bottom-right',\n  },\n}In some cases this indicator might not be useful for you. To remove it, open next.config.js and disable the buildActivity config in devIndicators object:next.config.js module.exports = {\n  devIndicators: {\n    buildActivity: false,", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/devIndicators"}
{"id": "709f6ebe1430-1", "text": "devIndicators: {\n    buildActivity: false,\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/devIndicators"}
{"id": "b629fa59edba-0", "text": "distDir\nYou can specify a name to use for a custom build directory to use instead of .next.\nOpen next.config.js and add the distDir config:\nnext.config.js module.exports = {\n  distDir: 'build',\n}\nNow if you run next build Next.js will use build instead of the default .next folder.\ndistDir should not leave your project directory. For example, ../build is an invalid directory.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/distDir"}
{"id": "9a46273eda24-0", "text": "env\nSince the release of Next.js 9.4 we now have a more intuitive and ergonomic experience for adding environment variables. Give it a try!\nExamples\nWith env\nGood to know: environment variables specified in this way will always be included in the JavaScript bundle, prefixing the environment variable name with NEXT_PUBLIC_ only has an effect when specifying them through the environment or .env files.\nTo add environment variables to the JavaScript bundle, open next.config.js and add the env config:\nnext.config.js module.exports = {\n  env: {\n    customKey: 'my-value',\n  },\n}\nNow you can access process.env.customKey in your code. For example:\n function Page() {\n  return <h1>The value of customKey is: {process.env.customKey}</h1>\n}\n \nexport default Page", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/env"}
{"id": "9a46273eda24-1", "text": "}\n \nexport default Page\nNext.js will replace process.env.customKey with 'my-value' at build time. Trying to destructure process.env variables won't work due to the nature of webpack DefinePlugin.\nFor example, the following line:\n return <h1>The value of customKey is: {process.env.customKey}</h1>\nWill end up being:\n return <h1>The value of customKey is: {'my-value'}</h1>", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/env"}
{"id": "7f0b58dfe772-0", "text": "eslint\nWhen ESLint is detected in your project, Next.js fails your production build (next build) when errors are present.\nIf you'd like Next.js to produce production code even when your application has ESLint errors, you can disable the built-in linting step completely. This is not recommended unless you already have ESLint configured to run in a separate part of your workflow (for example, in CI or a pre-commit hook).\nOpen next.config.js and enable the ignoreDuringBuilds option in the eslint config:\nnext.config.js module.exports = {\n  eslint: {\n    // Warning: This allows production builds to successfully complete even if\n    // your project has ESLint errors.\n    ignoreDuringBuilds: true,\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/eslint"}
{"id": "7dd190f95594-0", "text": "exportPathMap (Deprecated)\nThis feature is exclusive to next export and currently deprecated in favor of getStaticPaths with pages or generateStaticParams with app.\nExamples\nStatic Export\nexportPathMap allows you to specify a mapping of request paths to page destinations, to be used during export. Paths defined in exportPathMap will also be available when using next dev.\nLet's start with an example, to create a custom exportPathMap for an app with the following pages:\npages/index.js\npages/about.js\npages/post.js\nOpen next.config.js and add the following exportPathMap config:\nnext.config.js module.exports = {\n  exportPathMap: async function (\n    defaultPathMap,\n    { dev, dir, outDir, distDir, buildId }\n  ) {\n    return {\n      '/': { page: '/' },\n      '/about': { page: '/about' },", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/exportPathMap"}
{"id": "7dd190f95594-1", "text": "'/about': { page: '/about' },\n      '/p/hello-nextjs': { page: '/post', query: { title: 'hello-nextjs' } },\n      '/p/learn-nextjs': { page: '/post', query: { title: 'learn-nextjs' } },\n      '/p/deploy-nextjs': { page: '/post', query: { title: 'deploy-nextjs' } },\n    }\n  },\n}\nGood to know: the query field in exportPathMap cannot be used with automatically statically optimized pages or getStaticProps pages as they are rendered to HTML files at build-time and additional query information cannot be provided during next export.\nThe pages will then be exported as HTML files, for example, /about will become /about.html.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/exportPathMap"}
{"id": "7dd190f95594-2", "text": "exportPathMap is an async function that receives 2 arguments: the first one is defaultPathMap, which is the default map used by Next.js. The second argument is an object with:\ndev - true when exportPathMap is being called in development. false when running next export. In development exportPathMap is used to define routes.\ndir - Absolute path to the project directory\noutDir - Absolute path to the out/ directory (configurable with -o). When dev is true the value of outDir will be null.\ndistDir - Absolute path to the .next/ directory (configurable with the distDir config)\nbuildId - The generated build id\nThe returned object is a map of pages where the key is the pathname and the value is an object that accepts the following fields:\npage: String - the page inside the pages directory to render", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/exportPathMap"}
{"id": "7dd190f95594-3", "text": "page: String - the page inside the pages directory to render\nquery: Object - the query object passed to getInitialProps when prerendering. Defaults to {}\nThe exported pathname can also be a filename (for example, /readme.md), but you may need to set the Content-Type header to text/html when serving its content if it is different than .html.\nAdding a trailing slash\nIt is possible to configure Next.js to export pages as index.html files and require trailing slashes, /about becomes /about/index.html and is routable via /about/. This was the default behavior prior to Next.js 9.\nTo switch back and add a trailing slash, open next.config.js and enable the trailingSlash config:\nnext.config.js module.exports = {\n  trailingSlash: true,\n}\nCustomizing the output directory\nnext export will use out as the default output directory, you can customize this using the -o argument, like so:", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/exportPathMap"}
{"id": "7dd190f95594-4", "text": "Terminal next export -o outdir\nWarning: Using exportPathMap is deprecated and is overridden by getStaticPaths inside pages. We don't recommend using them together.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/exportPathMap"}
{"id": "0234f97df5cb-0", "text": "generateBuildId\nNext.js uses a constant id generated at build time to identify which version of your application is being served. This can cause problems in multi-server deployments when next build is run on every server. In order to keep a consistent build id between builds you can provide your own build id.\nOpen next.config.js and add the generateBuildId function:\nnext.config.js module.exports = {\n  generateBuildId: async () => {\n    // You can, for example, get the latest git commit hash here\n    return 'my-build-id'\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/generateBuildId"}
{"id": "5354c07a81e7-0", "text": "generateEtags\nNext.js will generate etags for every page by default. You may want to disable etag generation for HTML pages depending on your cache strategy.\nOpen next.config.js and disable the generateEtags option:\nnext.config.js module.exports = {\n  generateEtags: false,\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/generateEtags"}
{"id": "79cb28fc1d06-0", "text": "headers\nHeaders allow you to set custom HTTP headers on the response to an incoming request on a given path.\nTo set custom HTTP headers you can use the headers key in next.config.js:\nnext.config.js module.exports = {\n  async headers() {\n    return [\n      {\n        source: '/about',\n        headers: [\n          {\n            key: 'x-custom-header',\n            value: 'my custom header value',\n          },\n          {\n            key: 'x-another-custom-header',\n            value: 'my other custom header value',\n          },\n        ],\n      },\n    ]\n  },\n}\nheaders is an async function that expects an array to be returned holding objects with source and headers properties:\nsource is the incoming request path pattern.\nheaders is an array of response header objects, with key and value properties.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-1", "text": "headers is an array of response header objects, with key and value properties.\nbasePath: false or undefined - if false the basePath won't be included when matching, can be used for external rewrites only.\nlocale: false or undefined - whether the locale should not be included when matching.\nhas is an array of has objects with the type, key and value properties.\nmissing is an array of missing objects with the type, key and value properties.\nHeaders are checked before the filesystem which includes pages and /public files.\nHeader Overriding Behavior\nIf two headers match the same path and set the same header key, the last header key will override the first. Using the below headers, the path /hello will result in the header x-hello being world due to the last header value set being world.\nnext.config.js module.exports = {\n  async headers() {\n    return [\n      {\n        source: '/:path*',", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-2", "text": "return [\n      {\n        source: '/:path*',\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'there',\n          },\n        ],\n      },\n      {\n        source: '/hello',\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'world',\n          },\n        ],\n      },\n    ]\n  },\n}\nPath Matching\nPath matches are allowed, for example /blog/:slug will match /blog/hello-world (no nested paths):\nnext.config.js module.exports = {\n  async headers() {\n    return [\n      {\n        source: '/blog/:slug',\n        headers: [\n          {\n            key: 'x-slug',\n            value: ':slug', // Matched parameters can be used in the value\n          },\n          {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-3", "text": "},\n          {\n            key: 'x-slug-:slug', // Matched parameters can be used in the key\n            value: 'my other custom header value',\n          },\n        ],\n      },\n    ]\n  },\n}\nWildcard Path Matching\nTo match a wildcard path you can use * after a parameter, for example /blog/:slug* will match /blog/a/b/c/d/hello-world:\nnext.config.js module.exports = {\n  async headers() {\n    return [\n      {\n        source: '/blog/:slug*',\n        headers: [\n          {\n            key: 'x-slug',\n            value: ':slug*', // Matched parameters can be used in the value\n          },\n          {\n            key: 'x-slug-:slug*', // Matched parameters can be used in the key\n            value: 'my other custom header value',\n          },", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-4", "text": "value: 'my other custom header value',\n          },\n        ],\n      },\n    ]\n  },\n}\nRegex Path Matching\nTo match a regex path you can wrap the regex in parenthesis after a parameter, for example /blog/:slug(\\\\d{1,}) will match /blog/123 but not /blog/abc:\nnext.config.js module.exports = {\n  async headers() {\n    return [\n      {\n        source: '/blog/:post(\\\\d{1,})',\n        headers: [\n          {\n            key: 'x-post',\n            value: ':post',\n          },\n        ],\n      },\n    ]\n  },\n}\nThe following characters (, ), {, }, :, *, +, ? are used for regex path matching, so when used in the source as non-special values they must be escaped by adding \\\\ before them:", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-5", "text": "next.config.js module.exports = {\n  async headers() {\n    return [\n      {\n        // this will match `/english(default)/something` being requested\n        source: '/english\\\\(default\\\\)/:slug',\n        headers: [\n          {\n            key: 'x-header',\n            value: 'value',\n          },\n        ],\n      },\n    ]\n  },\n}\nHeader, Cookie, and Query Matching\nTo only apply a header when header, cookie, or query values also match the has field or don't match the missing field can be used. Both the source and all has items must match and all missing items must not match for the header to be applied.\nhas and missing items can have the following fields:\ntype: String - must be either header, cookie, host, or query.\nkey: String - the key from the selected type to match against.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-6", "text": "key: String - the key from the selected type to match against.\nvalue: String or undefined - the value to check for, if undefined any value will match. A regex like string can be used to capture a specific part of the value, e.g. if the value first-(?<paramName>.*) is used for first-second then second will be usable in the destination with :paramName.\nnext.config.js module.exports = {\n  async headers() {\n    return [\n      // if the header `x-add-header` is present,\n      // the `x-another-header` header will be applied\n      {\n        source: '/:path*',\n        has: [\n          {\n            type: 'header',\n            key: 'x-add-header',\n          },\n        ],\n        headers: [\n          {\n            key: 'x-another-header',\n            value: 'hello',\n          },\n        ],", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-7", "text": "value: 'hello',\n          },\n        ],\n      },\n      // if the header `x-no-header` is not present,\n      // the `x-another-header` header will be applied\n      {\n        source: '/:path*',\n        missing: [\n          {\n            type: 'header',\n            key: 'x-no-header',\n          },\n        ],\n        headers: [\n          {\n            key: 'x-another-header',\n            value: 'hello',\n          },\n        ],\n      },\n      // if the source, query, and cookie are matched,\n      // the `x-authorized` header will be applied\n      {\n        source: '/specific/:path*',\n        has: [\n          {\n            type: 'query',\n            key: 'page',\n            // the page value will not be available in the", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-8", "text": "key: 'page',\n            // the page value will not be available in the\n            // header key/values since value is provided and\n            // doesn't use a named capture group e.g. (?<page>home)\n            value: 'home',\n          },\n          {\n            type: 'cookie',\n            key: 'authorized',\n            value: 'true',\n          },\n        ],\n        headers: [\n          {\n            key: 'x-authorized',\n            value: ':authorized',\n          },\n        ],\n      },\n      // if the header `x-authorized` is present and\n      // contains a matching value, the `x-another-header` will be applied\n      {\n        source: '/:path*',\n        has: [\n          {\n            type: 'header',\n            key: 'x-authorized',", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-9", "text": "{\n            type: 'header',\n            key: 'x-authorized',\n            value: '(?<authorized>yes|true)',\n          },\n        ],\n        headers: [\n          {\n            key: 'x-another-header',\n            value: ':authorized',\n          },\n        ],\n      },\n      // if the host is `example.com`,\n      // this header will be applied\n      {\n        source: '/:path*',\n        has: [\n          {\n            type: 'host',\n            value: 'example.com',\n          },\n        ],\n        headers: [\n          {\n            key: 'x-another-header',\n            value: ':authorized',\n          },\n        ],\n      },\n    ]\n  },\n}\nHeaders with basePath support", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-10", "text": "],\n      },\n    ]\n  },\n}\nHeaders with basePath support\nWhen leveraging basePath support with headers each source is automatically prefixed with the basePath unless you add basePath: false to the header:\nnext.config.js module.exports = {\n  basePath: '/docs',\n \n  async headers() {\n    return [\n      {\n        source: '/with-basePath', // becomes /docs/with-basePath\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'world',\n          },\n        ],\n      },\n      {\n        source: '/without-basePath', // is not modified since basePath: false is set\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'world',\n          },\n        ],\n        basePath: false,\n      },\n    ]\n  },\n}\nHeaders with i18n support", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-11", "text": "},\n    ]\n  },\n}\nHeaders with i18n support\nWhen leveraging i18n support with headers each source is automatically prefixed to handle the configured locales unless you add locale: false to the header. If locale: false is used you must prefix the source with a locale for it to be matched correctly.\nnext.config.js module.exports = {\n  i18n: {\n    locales: ['en', 'fr', 'de'],\n    defaultLocale: 'en',\n  },\n \n  async headers() {\n    return [\n      {\n        source: '/with-locale', // automatically handles all locales\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'world',\n          },\n        ],\n      },\n      {\n        // does not handle locales automatically since locale: false is set\n        source: '/nl/with-locale-manual',", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-12", "text": "source: '/nl/with-locale-manual',\n        locale: false,\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'world',\n          },\n        ],\n      },\n      {\n        // this matches '/' since `en` is the defaultLocale\n        source: '/en',\n        locale: false,\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'world',\n          },\n        ],\n      },\n      {\n        // this gets converted to /(en|fr|de)/(.*) so will not match the top-level\n        // `/` or `/fr` routes like /:path* would\n        source: '/(.*)',\n        headers: [\n          {\n            key: 'x-hello',\n            value: 'world',\n          },\n        ],\n      },", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-13", "text": "value: 'world',\n          },\n        ],\n      },\n    ]\n  },\n}\nCache-Control\nYou can set the Cache-Control header in your Next.js API Routes by using the res.setHeader method:\npages/api/user.js export default function handler(req, res) {\n  res.setHeader('Cache-Control', 's-maxage=86400')\n  res.status(200).json({ name: 'John Doe' })\n}\nYou cannot set Cache-Control headers in next.config.js file as these will be overwritten in production to ensure that API Routes and static assets are cached effectively.\nIf you need to revalidate the cache of a page that has been statically generated, you can do so by setting the revalidate prop in the page's getStaticProps function.\nOptions\nX-DNS-Prefetch-Control", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-14", "text": "Options\nX-DNS-Prefetch-Control\nThis header controls DNS prefetching, allowing browsers to proactively perform domain name resolution on external links, images, CSS, JavaScript, and more. This prefetching is performed in the background, so the DNS is more likely to be resolved by the time the referenced items are needed. This reduces latency when the user clicks a link.\n {\n  key: 'X-DNS-Prefetch-Control',\n  value: 'on'\n}\nStrict-Transport-Security\nThis header informs browsers it should only be accessed using HTTPS, instead of using HTTP. Using the configuration below, all present and future subdomains will use HTTPS for a max-age of 2 years. This blocks access to pages or subdomains that can only be served over HTTP.\nIf you're deploying to Vercel, this header is not necessary as it's automatically added to all deployments unless you declare headers in your next.config.js.\n {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-15", "text": "{\n  key: 'Strict-Transport-Security',\n  value: 'max-age=63072000; includeSubDomains; preload'\n}\nX-XSS-Protection\nThis header stops pages from loading when they detect reflected cross-site scripting (XSS) attacks. Although this protection is not necessary when sites implement a strong Content-Security-Policy disabling the use of inline JavaScript ('unsafe-inline'), it can still provide protection for older web browsers that don't support CSP.\n {\n  key: 'X-XSS-Protection',\n  value: '1; mode=block'\n}\nX-Frame-Options\nThis header indicates whether the site should be allowed to be displayed within an iframe. This can prevent against clickjacking attacks. This header has been superseded by CSP's frame-ancestors option, which has better support in modern browsers.\n {\n  key: 'X-Frame-Options',", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-16", "text": "{\n  key: 'X-Frame-Options',\n  value: 'SAMEORIGIN'\n}\nPermissions-Policy\nThis header allows you to control which features and APIs can be used in the browser. It was previously named Feature-Policy. You can view the full list of permission options here.\n {\n  key: 'Permissions-Policy',\n  value: 'camera=(), microphone=(), geolocation=(), browsing-topics=()'\n}\nX-Content-Type-Options\nThis header prevents the browser from attempting to guess the type of content if the Content-Type header is not explicitly set. This can prevent XSS exploits for websites that allow users to upload and share files. For example, a user trying to download an image, but having it treated as a different Content-Type like an executable, which could be malicious. This header also applies to downloading browser extensions. The only valid value for this header is nosniff.\n {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-17", "text": "{\n  key: 'X-Content-Type-Options',\n  value: 'nosniff'\n}\nReferrer-Policy\nThis header controls how much information the browser includes when navigating from the current website (origin) to another. You can read about the different options here.\n {\n  key: 'Referrer-Policy',\n  value: 'origin-when-cross-origin'\n}\nContent-Security-Policy\nThis header helps prevent cross-site scripting (XSS), clickjacking and other code injection attacks. Content Security Policy (CSP) can specify allowed origins for content including scripts, stylesheets, images, fonts, objects, media (audio, video), iframes, and more.\nYou can read about the many different CSP options here.\nYou can add Content Security Policy directives using a template string.\n // Before defining your Security Headers\n// add Content Security Policy directives using a template string.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "79cb28fc1d06-18", "text": "// add Content Security Policy directives using a template string.\n \nconst ContentSecurityPolicy = `\n  default-src 'self';\n  script-src 'self';\n  child-src example.com;\n  style-src 'self' example.com;\n  font-src 'self';\n`\nWhen a directive uses a keyword such as self, wrap it in single quotes ''.\nIn the header's value, replace the new line with a space.\n {\n  key: 'Content-Security-Policy',\n  value: ContentSecurityPolicy.replace(/\\s{2,}/g, ' ').trim()\n}\nVersion History\nVersionChangesv13.3.0missing added.v10.2.0has added.v9.5.0Headers added.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/headers"}
{"id": "011a76187391-0", "text": "httpAgentOptions\nIn Node.js versions prior to 18, Next.js automatically polyfills fetch() with node-fetch and enables HTTP Keep-Alive by default.\nTo disable HTTP Keep-Alive for all fetch() calls on the server-side, open next.config.js and add the httpAgentOptions config:\nnext.config.js module.exports = {\n  httpAgentOptions: {\n    keepAlive: false,\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/httpAgentOptions"}
{"id": "c34ad0c51921-0", "text": "images\nIf you want to use a cloud provider to optimize images instead of using the Next.js built-in Image Optimization API, you can configure next.config.js with the following:\nnext.config.js module.exports = {\n  images: {\n    loader: 'custom',\n    loaderFile: './my/image/loader.js',\n  },\n}\nThis loaderFile must point to a file relative to the root of your Next.js application. The file must export a default function that returns a string, for example:\n export default function myImageLoader({ src, width, quality }) {\n  return `https://example.com/${src}?w=${width}&q=${quality || 75}`\n}\nAlternatively, you can use the loader prop to pass the function to each instance of next/image.\nExample Loader Configuration\nAkamai\nCloudinary\nCloudflare\nContentful\nFastly\nGumlet\nImageEngine\nImgix\nThumbor", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/images"}
{"id": "c34ad0c51921-1", "text": "Contentful\nFastly\nGumlet\nImageEngine\nImgix\nThumbor\nSupabase\nAkamai\n // Docs: https://techdocs.akamai.com/ivm/reference/test-images-on-demand\nexport default function akamaiLoader({ src, width, quality }) {\n  return `https://example.com/${src}?imwidth=${width}`\n}\nCloudinary\n // Demo: https://res.cloudinary.com/demo/image/upload/w_300,c_limit,q_auto/turtles.jpg\nexport default function cloudinaryLoader({ src, width, quality }) {\n  const params = ['f_auto', 'c_limit', `w_${width}`, `q_${quality || 'auto'}`]\n  return `https://example.com/${params.join(',')}${src}`\n}\nCloudflare\n // Docs: https://developers.cloudflare.com/images/url-format\nexport default function cloudflareLoader({ src, width, quality }) {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/images"}
{"id": "c34ad0c51921-2", "text": "export default function cloudflareLoader({ src, width, quality }) {\n  const params = [`width=${width}`, `quality=${quality || 75}`, 'format=auto']\n  return `https://example.com/cdn-cgi/image/${params.join(',')}/${src}`\n}\nContentful\n // Docs: https://www.contentful.com/developers/docs/references/images-api/\nexport default function contentfulLoader({ src, width, quality }) {\n  const url = new URL(`https://example.com${src}`)\n  url.searchParams.set('fm', 'webp')\n  url.searchParams.set('w', width.toString())\n  url.searchParams.set('q', (quality || 75).toString())\n  return url.href\n}\nFastly\n // Docs: https://developer.fastly.com/reference/io/\nexport default function fastlyLoader({ src, width, quality }) {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/images"}
{"id": "c34ad0c51921-3", "text": "export default function fastlyLoader({ src, width, quality }) {\n  const url = new URL(`https://example.com${src}`)\n  url.searchParams.set('auto', 'webp')\n  url.searchParams.set('width', width.toString())\n  url.searchParams.set('quality', (quality || 75).toString())\n  return url.href\n}\nGumlet\n // Docs: https://docs.gumlet.com/reference/image-transform-size\nexport default function gumletLoader({ src, width, quality }) {\n  const url = new URL(`https://example.com${src}`)\n  url.searchParams.set('format', 'auto')\n  url.searchParams.set('w', width.toString())\n  url.searchParams.set('q', (quality || 75).toString())\n  return url.href\n}\nImageEngine", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/images"}
{"id": "c34ad0c51921-4", "text": "return url.href\n}\nImageEngine\n // Docs: https://support.imageengine.io/hc/en-us/articles/360058880672-Directives\nexport default function imageengineLoader({ src, width, quality }) {\n  const compression = 100 - (quality || 50)\n  const params = [`w_${width}`, `cmpr_${compression}`)]\n  return `https://example.com${src}?imgeng=/${params.join('/')`\n}\nImgix\n // Demo: https://static.imgix.net/daisy.png?format=auto&fit=max&w=300\nexport default function imgixLoader({ src, width, quality }) {\n  const url = new URL(`https://example.com${src}`)\n  const params = url.searchParams\n  params.set('auto', params.getAll('auto').join(',') || 'format')\n  params.set('fit', params.get('fit') || 'max')", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/images"}
{"id": "c34ad0c51921-5", "text": "params.set('fit', params.get('fit') || 'max')\n  params.set('w', params.get('w') || width.toString())\n  params.set('q', (quality || 50).toString())\n  return url.href\n}\nThumbor\n // Docs: https://thumbor.readthedocs.io/en/latest/\nexport default function thumborLoader({ src, width, quality }) {\n  const params = [`${width}x0`, `filters:quality(${quality || 75})`]\n  return `https://example.com${params.join('/')}${src}`\n}\nSupabase\n // Docs: https://supabase.com/docs/guides/storage/image-transformations#nextjs-loader\nexport default function supabaseLoader({ src, width, quality }) {\n  const url = new URL(`https://example.com${src}`)\n  url.searchParams.set('width', width.toString())", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/images"}
{"id": "c34ad0c51921-6", "text": "url.searchParams.set('width', width.toString())\n  url.searchParams.set('quality', (quality || 75).toString())\n  return url.href\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/images"}
{"id": "6d334191be82-0", "text": "incrementalCacheHandlerPathIn Next.js, the default cache handler uses the filesystem cache. This requires no configuration, however, you can customize the cache handler by using the incrementalCacheHandlerPath field in next.config.js.\nnext.config.js module.exports = {\n  experimental: {\n    incrementalCacheHandlerPath: require.resolve('./cache-handler.js'),\n  },\n}\nHere's an example of a custom cache handler:\ncache-handler.js const cache = new Map()\n \nmodule.exports = class CacheHandler {\n  constructor(options) {\n    this.options = options\n    this.cache = {}\n  }\n \n  async get(key) {\n    return cache.get(key)\n  }\n \n  async set(key, data) {\n    cache.set(key, {\n      value: data,\n      lastModified: Date.now(),\n    })\n  }\n}\nAPI Reference", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/incrementalCacheHandlerPath"}
{"id": "6d334191be82-1", "text": "lastModified: Date.now(),\n    })\n  }\n}\nAPI Reference\nThe cache handler can implement the following methods: get, set, and revalidateTag.\nget()\nParameterTypeDescriptionkeystringThe key to the cached value.\nReturns the cached value or null if not found.\nset()\nParameterTypeDescriptionkeystringThe key to store the data under.dataData or nullThe data to be cached.\nReturns Promise<void>.\nrevalidateTag()\nParameterTypeDescriptiontagstringThe cache tag to revalidate.\nReturns Promise<void>. Learn more about revalidating data or the revalidateTag() function.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/incrementalCacheHandlerPath"}
{"id": "ac33f8f65260-0", "text": "mdxRsFor use with @next/mdx. Compile MDX files using the new Rust compiler.\nnext.config.js const withMDX = require('@next/mdx')()\n \n/** @type {import('next').NextConfig} */\nconst nextConfig = {\n  pageExtensions: ['ts', 'tsx', 'mdx'],\n  experimental: {\n    mdxRs: true,\n  },\n}\n \nmodule.exports = withMDX(nextConfig)", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/mdxRs"}
{"id": "809104ae5dba-0", "text": "onDemandEntries\nNext.js exposes some options that give you some control over how the server will dispose or keep in memory built pages in development.\nTo change the defaults, open next.config.js and add the onDemandEntries config:\nnext.config.js module.exports = {\n  onDemandEntries: {\n    // period (in ms) where the server will keep pages in the buffer\n    maxInactiveAge: 25 * 1000,\n    // number of pages that should be kept simultaneously without being disposed\n    pagesBufferLength: 2,\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/onDemandEntries"}
{"id": "8b54fc9d6ab3-0", "text": "output\nDuring a build, Next.js will automatically trace each page and its dependencies to determine all of the files that are needed for deploying a production version of your application.\nThis feature helps reduce the size of deployments drastically. Previously, when deploying with Docker you would need to have all files from your package's dependencies installed to run next start. Starting with Next.js 12, you can leverage Output File Tracing in the .next/ directory to only include the necessary files.\nFurthermore, this removes the need for the deprecated serverless target which can cause various issues and also creates unnecessary duplication.\nHow it Works\nDuring next build, Next.js will use @vercel/nft to statically analyze import, require, and fs usage to determine all files that a page might load.\nNext.js' production server is also traced for its needed files and output at .next/next-server.js.nft.json which can be leveraged in production.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "8b54fc9d6ab3-1", "text": "To leverage the .nft.json files emitted to the .next output directory, you can read the list of files in each trace that are relative to the .nft.json file and then copy them to your deployment location.\nAutomatically Copying Traced Files\nNext.js can automatically create a standalone folder that copies only the necessary files for a production deployment including select files in node_modules.\nTo leverage this automatic copying you can enable it in your next.config.js:\nnext.config.js module.exports = {\n  output: 'standalone',\n}\nThis will create a folder at .next/standalone which can then be deployed on its own without installing node_modules.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "8b54fc9d6ab3-2", "text": "Additionally, a minimal server.js file is also output which can be used instead of next start. This minimal server does not copy the public or .next/static folders by default as these should ideally be handled by a CDN instead, although these folders can be copied to the standalone/public and standalone/.next/static folders manually, after which server.js file will serve these automatically.\nGood to know:\nnext.config.js is read during next build and serialized into the server.js output file. If the legacy serverRuntimeConfig or publicRuntimeConfig options are being used, the values will be specific to values at build time.\nIf your project uses Image Optimization with the default loader, you must install sharp as a dependency:\nIf your project needs alternative port or hostname for listening, you can define PORT and HOSTNAME environment variables, before running server.js. For example, PORT=3000 HOSTNAME=localhost node server.js.\nTerminal npm i sharp\nTerminal yarn add sharp\nTerminal pnpm add sharp", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "8b54fc9d6ab3-3", "text": "Terminal npm i sharp\nTerminal yarn add sharp\nTerminal pnpm add sharp\nCaveats\nWhile tracing in monorepo setups, the project directory is used for tracing by default. For next build packages/web-app, packages/web-app would be the tracing root and any files outside of that folder will not be included. To include files outside of this folder you can set experimental.outputFileTracingRoot in your next.config.js.\npackages/web-app/next.config.js module.exports = {\n  experimental: {\n    // this includes files from the monorepo base two directories up\n    outputFileTracingRoot: path.join(__dirname, '../../'),\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "8b54fc9d6ab3-4", "text": "outputFileTracingRoot: path.join(__dirname, '../../'),\n  },\n}\nThere are some cases in which Next.js might fail to include required files, or might incorrectly include unused files. In those cases, you can leverage experimental.outputFileTracingExcludes and experimental.outputFileTracingIncludes respectively in next.config.js. Each config accepts an object with minimatch globs for the key to match specific pages and a value of an array with globs relative to the project's root to either include or exclude in the trace.\nnext.config.js module.exports = {\n  experimental: {\n    outputFileTracingExcludes: {\n      '/api/hello': ['./un-necessary-folder/**/*'],\n    },\n    outputFileTracingIncludes: {\n      '/api/another': ['./necessary-folder/**/*'],\n    },\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "8b54fc9d6ab3-5", "text": "},\n  },\n}\nCurrently, Next.js does not do anything with the emitted .nft.json files. The files must be read by your deployment platform, for example Vercel, to create a minimal deployment. In a future release, a new command is planned to utilize these .nft.json files.\nExperimental turbotrace\nTracing dependencies can be slow because it requires very complex computations and analysis. We created turbotrace in Rust as a faster and smarter alternative to the JavaScript implementation.\nTo enable it, you can add the following configuration to your next.config.js:\nnext.config.js module.exports = {\n  experimental: {\n    turbotrace: {\n      // control the log level of the turbotrace, default is `error`\n      logLevel?:\n      | 'bug'\n      | 'fatal'\n      | 'error'\n      | 'warning'\n      | 'hint'", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "8b54fc9d6ab3-6", "text": "| 'error'\n      | 'warning'\n      | 'hint'\n      | 'note'\n      | 'suggestions'\n      | 'info',\n      // control if the log of turbotrace should contain the details of the analysis, default is `false`\n      logDetail?: boolean\n      // show all log messages without limit\n      // turbotrace only show 1 log message for each categories by default\n      logAll?: boolean\n      // control the context directory of the turbotrace\n      // files outside of the context directory will not be traced\n      // set the `experimental.outputFileTracingRoot` has the same effect\n      // if the `experimental.outputFileTracingRoot` and this option are both set, the `experimental.turbotrace.contextDirectory` will be used\n      contextDirectory?: string", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "8b54fc9d6ab3-7", "text": "contextDirectory?: string\n      // if there is `process.cwd()` expression in your code, you can set this option to tell `turbotrace` the value of `process.cwd()` while tracing.\n      // for example the require(process.cwd() + '/package.json') will be traced as require('/path/to/cwd/package.json')\n      processCwd?: string\n      // control the maximum memory usage of the `turbotrace`, in `MB`, default is `6000`.\n      memoryLimit?: number\n    },\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/output"}
{"id": "cf657690c5a2-0", "text": "pageExtensions\nBy default, Next.js accepts files with the following extensions: .tsx, .ts, .jsx, .js. This can be modified to allow other extensions like markdown (.md, .mdx).next.config.js const withMDX = require('@next/mdx')()\n \n/** @type {import('next').NextConfig} */\nconst nextConfig = {\n  pageExtensions: ['ts', 'tsx', 'mdx'],\n  experimental: {\n    mdxRs: true,\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/pageExtensions"}
{"id": "cf657690c5a2-1", "text": "experimental: {\n    mdxRs: true,\n  },\n}\n \nmodule.exports = withMDX(nextConfig)For custom advanced configuration of Next.js, you can create a next.config.js or next.config.mjs file in the root of your project directory (next to package.json).next.config.js is a regular Node.js module, not a JSON file. It gets used by the Next.js server and build phases, and it's not included in the browser build.Take a look at the following next.config.js example:next.config.js /**\n * @type {import('next').NextConfig}\n */\nconst nextConfig = {\n  /* config options here */\n}\n \nmodule.exports = nextConfigIf you need ECMAScript modules, you can use next.config.mjs:next.config.mjs /**\n * @type {import('next').NextConfig}\n */\nconst nextConfig = {\n  /* config options here */", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/pageExtensions"}
{"id": "cf657690c5a2-2", "text": "*/\nconst nextConfig = {\n  /* config options here */\n}\n \nexport default nextConfigYou can also use a function:next.config.mjs module.exports = (phase, { defaultConfig }) => {\n  /**\n   * @type {import('next').NextConfig}\n   */\n  const nextConfig = {\n    /* config options here */\n  }\n  return nextConfig\n}Since Next.js 12.1.0, you can use an async function:next.config.js module.exports = async (phase, { defaultConfig }) => {\n  /**\n   * @type {import('next').NextConfig}\n   */\n  const nextConfig = {\n    /* config options here */\n  }\n  return nextConfig", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/pageExtensions"}
{"id": "cf657690c5a2-3", "text": "/* config options here */\n  }\n  return nextConfig\n}phase is the current context in which the configuration is loaded. You can see the available phases. Phases can be imported from next/constants: const { PHASE_DEVELOPMENT_SERVER } = require('next/constants')\n \nmodule.exports = (phase, { defaultConfig }) => {\n  if (phase === PHASE_DEVELOPMENT_SERVER) {\n    return {\n      /* development only config options here */\n    }\n  }\n \n  return {\n    /* config options for all phases except development here */\n  }", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/pageExtensions"}
{"id": "cf657690c5a2-4", "text": "return {\n    /* config options for all phases except development here */\n  }\n}The commented lines are the place where you can put the configs allowed by next.config.js, which are defined in this file.However, none of the configs are required, and it's not necessary to understand what each config does. Instead, search for the features you need to enable or modify in this section and they will show you what to do.\nAvoid using new JavaScript features not available in your target Node.js version. next.config.js will not be parsed by Webpack, Babel or TypeScript.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/pageExtensions"}
{"id": "cb9b6476e3d9-0", "text": "poweredByHeader\nBy default Next.js will add the x-powered-by header. To opt-out of it, open next.config.js and disable the poweredByHeader config:\nnext.config.js module.exports = {\n  poweredByHeader: false,\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/poweredByHeader"}
{"id": "619ac6f19618-0", "text": "productionBrowserSourceMaps\nSource Maps are enabled by default during development. During production builds, they are disabled to prevent you leaking your source on the client, unless you specifically opt-in with the configuration flag.\nNext.js provides a configuration flag you can use to enable browser source map generation during the production build:\nnext.config.js module.exports = {\n  productionBrowserSourceMaps: true,\n}\nWhen the productionBrowserSourceMaps option is enabled, the source maps will be output in the same directory as the JavaScript files. Next.js will automatically serve these files when requested.\nAdding source maps can increase next build time\nIncreases memory usage during next build", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/productionBrowserSourceMaps"}
{"id": "7d62f05b7e19-0", "text": "reactStrictMode\nGood to know: Since Next.js 13.4, Strict Mode is true by default with app router, so the above configuration is only necessary for pages. You can still disable Strict Mode by setting reactStrictMode: false.\nSuggested: We strongly suggest you enable Strict Mode in your Next.js application to better prepare your application for the future of React.\nReact's Strict Mode is a development mode only feature for highlighting potential problems in an application. It helps to identify unsafe lifecycles, legacy API usage, and a number of other features.\nThe Next.js runtime is Strict Mode-compliant. To opt-in to Strict Mode, configure the following option in your next.config.js:\nnext.config.js module.exports = {\n  reactStrictMode: true,\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/reactStrictMode"}
{"id": "7d62f05b7e19-1", "text": "next.config.js module.exports = {\n  reactStrictMode: true,\n}\nIf you or your team are not ready to use Strict Mode in your entire application, that's OK! You can incrementally migrate on a page-by-page basis using <React.StrictMode>.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/reactStrictMode"}
{"id": "b6efd1cc8e7e-0", "text": "redirects\nRedirects allow you to redirect an incoming request path to a different destination path.\nTo use redirects you can use the redirects key in next.config.js:\nnext.config.js module.exports = {\n  async redirects() {\n    return [\n      {\n        source: '/about',\n        destination: '/',\n        permanent: true,\n      },\n    ]\n  },\n}\nredirects is an async function that expects an array to be returned holding objects with source, destination, and permanent properties:\nsource is the incoming request path pattern.\ndestination is the path you want to route to.\npermanent true or false - if true will use the 308 status code which instructs clients/search engines to cache the redirect forever, if false will use the 307 status code which is temporary and is not cached.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-1", "text": "Why does Next.js use 307 and 308? Traditionally a 302 was used for a temporary redirect, and a 301 for a permanent redirect, but many browsers changed the request method of the redirect to GET, regardless of the original method. For example, if the browser made a request to POST /v1/users which returned status code 302 with location /v2/users, the subsequent request might be GET /v2/users instead of the expected POST /v2/users. Next.js uses the 307 temporary redirect, and 308 permanent redirect status codes to explicitly preserve the request method used.\nbasePath: false or undefined - if false the basePath won't be included when matching, can be used for external redirects only.\nlocale: false or undefined - whether the locale should not be included when matching.\nhas is an array of has objects with the type, key and value properties.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-2", "text": "has is an array of has objects with the type, key and value properties.\nmissing is an array of missing objects with the type, key and value properties.\nRedirects are checked before the filesystem which includes pages and /public files.\nRedirects are not applied to client-side routing (Link, router.push), unless Middleware is present and matches the path.\nWhen a redirect is applied, any query values provided in the request will be passed through to the redirect destination. For example, see the following redirect configuration:\n {\n  source: '/old-blog/:path*',\n  destination: '/blog/:path*',\n  permanent: false\n}\nWhen /old-blog/post-1?hello=world is requested, the client will be redirected to /blog/post-1?hello=world.\nPath Matching\nPath matches are allowed, for example /old-blog/:slug will match /old-blog/hello-world (no nested paths):", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-3", "text": "next.config.js module.exports = {\n  async redirects() {\n    return [\n      {\n        source: '/old-blog/:slug',\n        destination: '/news/:slug', // Matched parameters can be used in the destination\n        permanent: true,\n      },\n    ]\n  },\n}\nWildcard Path Matching\nTo match a wildcard path you can use * after a parameter, for example /blog/:slug* will match /blog/a/b/c/d/hello-world:\nnext.config.js module.exports = {\n  async redirects() {\n    return [\n      {\n        source: '/blog/:slug*',\n        destination: '/news/:slug*', // Matched parameters can be used in the destination\n        permanent: true,\n      },\n    ]\n  },\n}\nRegex Path Matching", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-4", "text": "},\n    ]\n  },\n}\nRegex Path Matching\nTo match a regex path you can wrap the regex in parentheses after a parameter, for example /post/:slug(\\\\d{1,}) will match /post/123 but not /post/abc:\nnext.config.js module.exports = {\n  async redirects() {\n    return [\n      {\n        source: '/post/:slug(\\\\d{1,})',\n        destination: '/news/:slug', // Matched parameters can be used in the destination\n        permanent: false,\n      },\n    ]\n  },\n}\nThe following characters (, ), {, }, :, *, +, ? are used for regex path matching, so when used in the source as non-special values they must be escaped by adding \\\\ before them:\nnext.config.js module.exports = {\n  async redirects() {\n    return [\n      {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-5", "text": "async redirects() {\n    return [\n      {\n        // this will match `/english(default)/something` being requested\n        source: '/english\\\\(default\\\\)/:slug',\n        destination: '/en-us/:slug',\n        permanent: false,\n      },\n    ]\n  },\n}\nHeader, Cookie, and Query Matching\nTo only match a redirect when header, cookie, or query values also match the has field or don't match the missing field can be used. Both the source and all has items must match and all missing items must not match for the redirect to be applied.\nhas and missing items can have the following fields:\ntype: String - must be either header, cookie, host, or query.\nkey: String - the key from the selected type to match against.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-6", "text": "key: String - the key from the selected type to match against.\nvalue: String or undefined - the value to check for, if undefined any value will match. A regex like string can be used to capture a specific part of the value, e.g. if the value first-(?<paramName>.*) is used for first-second then second will be usable in the destination with :paramName.\nnext.config.js module.exports = {\n  async redirects() {\n    return [\n      // if the header `x-redirect-me` is present,\n      // this redirect will be applied\n      {\n        source: '/:path((?!another-page$).*)',\n        has: [\n          {\n            type: 'header',\n            key: 'x-redirect-me',\n          },\n        ],\n        permanent: false,\n        destination: '/another-page',\n      },", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-7", "text": "],\n        permanent: false,\n        destination: '/another-page',\n      },\n      // if the header `x-dont-redirect` is present,\n      // this redirect will NOT be applied\n      {\n        source: '/:path((?!another-page$).*)',\n        missing: [\n          {\n            type: 'header',\n            key: 'x-do-not-redirect',\n          },\n        ],\n        permanent: false,\n        destination: '/another-page',\n      },\n      // if the source, query, and cookie are matched,\n      // this redirect will be applied\n      {\n        source: '/specific/:path*',\n        has: [\n          {\n            type: 'query',\n            key: 'page',\n            // the page value will not be available in the\n            // destination since value is provided and doesn't", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-8", "text": "// destination since value is provided and doesn't\n            // use a named capture group e.g. (?<page>home)\n            value: 'home',\n          },\n          {\n            type: 'cookie',\n            key: 'authorized',\n            value: 'true',\n          },\n        ],\n        permanent: false,\n        destination: '/another/:path*',\n      },\n      // if the header `x-authorized` is present and\n      // contains a matching value, this redirect will be applied\n      {\n        source: '/',\n        has: [\n          {\n            type: 'header',\n            key: 'x-authorized',\n            value: '(?<authorized>yes|true)',\n          },\n        ],\n        permanent: false,\n        destination: '/home?authorized=:authorized',\n      },\n      // if the host is `example.com`,", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-9", "text": "},\n      // if the host is `example.com`,\n      // this redirect will be applied\n      {\n        source: '/:path((?!another-page$).*)',\n        has: [\n          {\n            type: 'host',\n            value: 'example.com',\n          },\n        ],\n        permanent: false,\n        destination: '/another-page',\n      },\n    ]\n  },\n}\nRedirects with basePath support\nWhen leveraging basePath support with redirects each source and destination is automatically prefixed with the basePath unless you add basePath: false to the redirect:\nnext.config.js module.exports = {\n  basePath: '/docs',\n \n  async redirects() {\n    return [\n      {\n        source: '/with-basePath', // automatically becomes /docs/with-basePath\n        destination: '/another', // automatically becomes /docs/another\n        permanent: false,\n      },", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-10", "text": "permanent: false,\n      },\n      {\n        // does not add /docs since basePath: false is set\n        source: '/without-basePath',\n        destination: 'https://example.com',\n        basePath: false,\n        permanent: false,\n      },\n    ]\n  },\n}\nRedirects with i18n support\nWhen leveraging i18n support with redirects each source and destination is automatically prefixed to handle the configured locales unless you add locale: false to the redirect. If locale: false is used you must prefix the source and destination with a locale for it to be matched correctly.\nnext.config.js module.exports = {\n  i18n: {\n    locales: ['en', 'fr', 'de'],\n    defaultLocale: 'en',\n  },\n \n  async redirects() {\n    return [\n      {\n        source: '/with-locale', // automatically handles all locales", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-11", "text": "{\n        source: '/with-locale', // automatically handles all locales\n        destination: '/another', // automatically passes the locale on\n        permanent: false,\n      },\n      {\n        // does not handle locales automatically since locale: false is set\n        source: '/nl/with-locale-manual',\n        destination: '/nl/another',\n        locale: false,\n        permanent: false,\n      },\n      {\n        // this matches '/' since `en` is the defaultLocale\n        source: '/en',\n        destination: '/en/another',\n        locale: false,\n        permanent: false,\n      },\n      // it's possible to match all locales even when locale: false is set\n      {\n        source: '/:locale/page',\n        destination: '/en/newpage',\n        permanent: false,\n        locale: false,\n      }\n      {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-12", "text": "permanent: false,\n        locale: false,\n      }\n      {\n        // this gets converted to /(en|fr|de)/(.*) so will not match the top-level\n        // `/` or `/fr` routes like /:path* would\n        source: '/(.*)',\n        destination: '/another',\n        permanent: false,\n      },\n    ]\n  },\n}\nIn some rare cases, you might need to assign a custom status code for older HTTP Clients to properly redirect. In these cases, you can use the statusCode property instead of the permanent property, but not both. To to ensure IE11 compatibility, a Refresh header is automatically added for the 308 status code.\nOther Redirects\nInside API Routes, you can use res.redirect().\nInside getStaticProps and getServerSideProps, you can redirect specific pages at request-time.\nVersion History", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "b6efd1cc8e7e-13", "text": "Version History\nVersionChangesv13.3.0missing added.v10.2.0has added.v9.5.0redirects added.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/redirects"}
{"id": "467e2fc53597-0", "text": "rewrites\nRewrites allow you to map an incoming request path to a different destination path.\nRewrites act as a URL proxy and mask the destination path, making it appear the user hasn't changed their location on the site. In contrast, redirects will reroute to a new page and show the URL changes.\nTo use rewrites you can use the rewrites key in next.config.js:\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {\n        source: '/about',\n        destination: '/',\n      },\n    ]\n  },\n}\nRewrites are applied to client-side routing, a <Link href=\"/about\"> will have the rewrite applied in the above example.\nrewrites is an async function that expects to return either an array or an object of arrays (see below) holding objects with source and destination properties:\nsource: String - is the incoming request path pattern.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-1", "text": "source: String - is the incoming request path pattern.\ndestination: String is the path you want to route to.\nbasePath: false or undefined - if false the basePath won't be included when matching, can be used for external rewrites only.\nlocale: false or undefined - whether the locale should not be included when matching.\nhas is an array of has objects with the type, key and value properties.\nmissing is an array of missing objects with the type, key and value properties.\nWhen the rewrites function returns an array, rewrites are applied after checking the filesystem (pages and /public files) and before dynamic routes. When the rewrites function returns an object of arrays with a specific shape, this behavior can be changed and more finely controlled, as of v10.1 of Next.js:\nnext.config.js module.exports = {\n  async rewrites() {\n    return {\n      beforeFiles: [", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-2", "text": "async rewrites() {\n    return {\n      beforeFiles: [\n        // These rewrites are checked after headers/redirects\n        // and before all files including _next/public files which\n        // allows overriding page files\n        {\n          source: '/some-page',\n          destination: '/somewhere-else',\n          has: [{ type: 'query', key: 'overrideMe' }],\n        },\n      ],\n      afterFiles: [\n        // These rewrites are checked after pages/public files\n        // are checked but before dynamic routes\n        {\n          source: '/non-existent',\n          destination: '/somewhere-else',\n        },\n      ],\n      fallback: [\n        // These rewrites are checked after both pages/public files\n        // and dynamic routes are checked\n        {\n          source: '/:path*',", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-3", "text": "// and dynamic routes are checked\n        {\n          source: '/:path*',\n          destination: `https://my-old-site.com/:path*`,\n        },\n      ],\n    }\n  },\n}\nGood to know: rewrites in beforeFiles do not check the filesystem/dynamic routes immediately after matching a source, they continue until all beforeFiles have been checked.\nThe order Next.js routes are checked is:\nheaders are checked/applied\nredirects are checked/applied\nbeforeFiles rewrites are checked/applied\nstatic files from the public directory, _next/static files, and non-dynamic pages are checked/served\nafterFiles rewrites are checked/applied, if one of these rewrites is matched we check dynamic routes/static files after each match", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-4", "text": "fallback rewrites are checked/applied, these are applied before rendering the 404 page and after dynamic routes/all static assets have been checked. If you use fallback: true/'blocking' in getStaticPaths, the fallback rewrites defined in your next.config.js will not be run.\nRewrite parameters\nWhen using parameters in a rewrite the parameters will be passed in the query by default when none of the parameters are used in the destination.\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {\n        source: '/old-about/:path*',\n        destination: '/about', // The :path parameter isn't used here so will be automatically passed in the query\n      },\n    ]\n  },\n}\nIf a parameter is used in the destination none of the parameters will be automatically passed in the query.\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-5", "text": "async rewrites() {\n    return [\n      {\n        source: '/docs/:path*',\n        destination: '/:path*', // The :path parameter is used here so will not be automatically passed in the query\n      },\n    ]\n  },\n}\nYou can still pass the parameters manually in the query if one is already used in the destination by specifying the query in the destination.\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {\n        source: '/:first/:second',\n        destination: '/:first?second=:second',\n        // Since the :first parameter is used in the destination the :second parameter\n        // will not automatically be added in the query although we can manually add it\n        // as shown above\n      },\n    ]\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-6", "text": "// as shown above\n      },\n    ]\n  },\n}\nGood to know: Static pages from Automatic Static Optimization or prerendering params from rewrites will be parsed on the client after hydration and provided in the query.\nPath Matching\nPath matches are allowed, for example /blog/:slug will match /blog/hello-world (no nested paths):\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {\n        source: '/blog/:slug',\n        destination: '/news/:slug', // Matched parameters can be used in the destination\n      },\n    ]\n  },\n}\nWildcard Path Matching\nTo match a wildcard path you can use * after a parameter, for example /blog/:slug* will match /blog/a/b/c/d/hello-world:\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-7", "text": "async rewrites() {\n    return [\n      {\n        source: '/blog/:slug*',\n        destination: '/news/:slug*', // Matched parameters can be used in the destination\n      },\n    ]\n  },\n}\nRegex Path Matching\nTo match a regex path you can wrap the regex in parenthesis after a parameter, for example /blog/:slug(\\\\d{1,}) will match /blog/123 but not /blog/abc:\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {\n        source: '/old-blog/:post(\\\\d{1,})',\n        destination: '/blog/:post', // Matched parameters can be used in the destination\n      },\n    ]\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-8", "text": "},\n    ]\n  },\n}\nThe following characters (, ), {, }, :, *, +, ? are used for regex path matching, so when used in the source as non-special values they must be escaped by adding \\\\ before them:\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {\n        // this will match `/english(default)/something` being requested\n        source: '/english\\\\(default\\\\)/:slug',\n        destination: '/en-us/:slug',\n      },\n    ]\n  },\n}\nHeader, Cookie, and Query Matching\nTo only match a rewrite when header, cookie, or query values also match the has field or don't match the missing field can be used. Both the source and all has items must match and all missing items must not match for the rewrite to be applied.\nhas and missing items can have the following fields:", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-9", "text": "has and missing items can have the following fields:\ntype: String - must be either header, cookie, host, or query.\nkey: String - the key from the selected type to match against.\nvalue: String or undefined - the value to check for, if undefined any value will match. A regex like string can be used to capture a specific part of the value, e.g. if the value first-(?<paramName>.*) is used for first-second then second will be usable in the destination with :paramName.\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      // if the header `x-rewrite-me` is present,\n      // this rewrite will be applied\n      {\n        source: '/:path*',\n        has: [\n          {\n            type: 'header',\n            key: 'x-rewrite-me',\n          },\n        ],", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-10", "text": "key: 'x-rewrite-me',\n          },\n        ],\n        destination: '/another-page',\n      },\n      // if the header `x-rewrite-me` is not present,\n      // this rewrite will be applied\n      {\n        source: '/:path*',\n        missing: [\n          {\n            type: 'header',\n            key: 'x-rewrite-me',\n          },\n        ],\n        destination: '/another-page',\n      },\n      // if the source, query, and cookie are matched,\n      // this rewrite will be applied\n      {\n        source: '/specific/:path*',\n        has: [\n          {\n            type: 'query',\n            key: 'page',\n            // the page value will not be available in the\n            // destination since value is provided and doesn't\n            // use a named capture group e.g. (?<page>home)", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-11", "text": "// use a named capture group e.g. (?<page>home)\n            value: 'home',\n          },\n          {\n            type: 'cookie',\n            key: 'authorized',\n            value: 'true',\n          },\n        ],\n        destination: '/:path*/home',\n      },\n      // if the header `x-authorized` is present and\n      // contains a matching value, this rewrite will be applied\n      {\n        source: '/:path*',\n        has: [\n          {\n            type: 'header',\n            key: 'x-authorized',\n            value: '(?<authorized>yes|true)',\n          },\n        ],\n        destination: '/home?authorized=:authorized',\n      },\n      // if the host is `example.com`,\n      // this rewrite will be applied\n      {\n        source: '/:path*',\n        has: [", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-12", "text": "{\n        source: '/:path*',\n        has: [\n          {\n            type: 'host',\n            value: 'example.com',\n          },\n        ],\n        destination: '/another-page',\n      },\n    ]\n  },\n}\nRewriting to an external URL\nExamples\nIncremental adoption of Next.js\nUsing Multiple Zones\nRewrites allow you to rewrite to an external url. This is especially useful for incrementally adopting Next.js. The following is an example rewrite for redirecting the /blog route of your main app to an external site.\nnext.config.js module.exports = {\n  async rewrites() {\n    return [\n      {\n        source: '/blog',\n        destination: 'https://example.com/blog',\n      },\n      {\n        source: '/blog/:slug',", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-13", "text": "},\n      {\n        source: '/blog/:slug',\n        destination: 'https://example.com/blog/:slug', // Matched parameters can be used in the destination\n      },\n    ]\n  },\n}\nIf you're using trailingSlash: true, you also need to insert a trailing slash in the source parameter. If the destination server is also expecting a trailing slash it should be included in the destination parameter as well.\nnext.config.js module.exports = {\n  trailingSlash: true,\n  async rewrites() {\n    return [\n      {\n        source: '/blog/',\n        destination: 'https://example.com/blog/',\n      },\n      {\n        source: '/blog/:path*/',\n        destination: 'https://example.com/blog/:path*/',\n      },\n    ]\n  },\n}\nIncremental adoption of Next.js", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-14", "text": "},\n    ]\n  },\n}\nIncremental adoption of Next.js\nYou can also have Next.js fall back to proxying to an existing website after checking all Next.js routes.\nThis way you don't have to change the rewrites configuration when migrating more pages to Next.js\nnext.config.js module.exports = {\n  async rewrites() {\n    return {\n      fallback: [\n        {\n          source: '/:path*',\n          destination: `https://custom-routes-proxying-endpoint.vercel.app/:path*`,\n        },\n      ],\n    }\n  },\n}\nRewrites with basePath support\nWhen leveraging basePath support with rewrites each source and destination is automatically prefixed with the basePath unless you add basePath: false to the rewrite:\nnext.config.js module.exports = {\n  basePath: '/docs',\n \n  async rewrites() {\n    return [\n      {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-15", "text": "async rewrites() {\n    return [\n      {\n        source: '/with-basePath', // automatically becomes /docs/with-basePath\n        destination: '/another', // automatically becomes /docs/another\n      },\n      {\n        // does not add /docs to /without-basePath since basePath: false is set\n        // Note: this can not be used for internal rewrites e.g. `destination: '/another'`\n        source: '/without-basePath',\n        destination: 'https://example.com',\n        basePath: false,\n      },\n    ]\n  },\n}\nRewrites with i18n support\nWhen leveraging i18n support with rewrites each source and destination is automatically prefixed to handle the configured locales unless you add locale: false to the rewrite. If locale: false is used you must prefix the source and destination with a locale for it to be matched correctly.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-16", "text": "next.config.js module.exports = {\n  i18n: {\n    locales: ['en', 'fr', 'de'],\n    defaultLocale: 'en',\n  },\n \n  async rewrites() {\n    return [\n      {\n        source: '/with-locale', // automatically handles all locales\n        destination: '/another', // automatically passes the locale on\n      },\n      {\n        // does not handle locales automatically since locale: false is set\n        source: '/nl/with-locale-manual',\n        destination: '/nl/another',\n        locale: false,\n      },\n      {\n        // this matches '/' since `en` is the defaultLocale\n        source: '/en',\n        destination: '/en/another',\n        locale: false,\n      },\n      {\n        // it's possible to match all locales even when locale: false is set", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "467e2fc53597-17", "text": "{\n        // it's possible to match all locales even when locale: false is set\n        source: '/:locale/api-alias/:path*',\n        destination: '/api/:path*',\n        locale: false,\n      },\n      {\n        // this gets converted to /(en|fr|de)/(.*) so will not match the top-level\n        // `/` or `/fr` routes like /:path* would\n        source: '/(.*)',\n        destination: '/another',\n      },\n    ]\n  },\n}\nVersion History\nVersionChangesv13.3.0missing added.v10.2.0has added.v9.5.0Headers added.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/rewrites"}
{"id": "674f101b75a3-0", "text": "Runtime Config\nGood to know: This feature is considered legacy and does not work with Automatic Static Optimization, Output File Tracing, or React Server Components. Please use environment variables instead to avoid initialization overhead.\nTo add runtime configuration to your app, open next.config.js and add the publicRuntimeConfig and serverRuntimeConfig configs:\nnext.config.js module.exports = {\n  serverRuntimeConfig: {\n    // Will only be available on the server side\n    mySecret: 'secret',\n    secondSecret: process.env.SECOND_SECRET, // Pass through env variables\n  },\n  publicRuntimeConfig: {\n    // Will be available on both server and client\n    staticFolder: '/static',\n  },\n}\nPlace any server-only runtime config under serverRuntimeConfig.\nAnything accessible to both client and server-side code should be under publicRuntimeConfig.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/runtime-configuration"}
{"id": "674f101b75a3-1", "text": "Anything accessible to both client and server-side code should be under publicRuntimeConfig.\nA page that relies on publicRuntimeConfig must use getInitialProps or getServerSideProps or your application must have a Custom App with getInitialProps to opt-out of Automatic Static Optimization. Runtime configuration won't be available to any page (or component in a page) without being server-side rendered.\nTo get access to the runtime configs in your app use next/config, like so:\n import getConfig from 'next/config'\nimport Image from 'next/image'\n \n// Only holds serverRuntimeConfig and publicRuntimeConfig\nconst { serverRuntimeConfig, publicRuntimeConfig } = getConfig()\n// Will only be available on the server-side\nconsole.log(serverRuntimeConfig.mySecret)\n// Will be available on both server-side and client-side\nconsole.log(publicRuntimeConfig.staticFolder)\n \nfunction MyImage() {\n  return (\n    <div>\n      <Image", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/runtime-configuration"}
{"id": "674f101b75a3-2", "text": "function MyImage() {\n  return (\n    <div>\n      <Image\n        src={`${publicRuntimeConfig.staticFolder}/logo.png`}\n        alt=\"logo\"\n        layout=\"fill\"\n      />\n    </div>\n  )\n}\n \nexport default MyImage", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/runtime-configuration"}
{"id": "3c908699141c-0", "text": "serverComponentsExternalPackagesDependencies used inside Server Components and Route Handlers will automatically be bundled by Next.js.\nIf a dependency is using Node.js specific features, you can choose to opt-out specific dependencies from the Server Components bundling and use native Node.js require.\nnext.config.js /** @type {import('next').NextConfig} */\nconst nextConfig = {\n  experimental: {\n    serverComponentsExternalPackages: ['@acme/ui'],\n  },\n}\n \nmodule.exports = nextConfig\nNext.js includes a short list of popular packages that currently are working on compatibility and automatically opt-ed out:\n@aws-sdk/client-s3\n@aws-sdk/s3-presigned-post\n@blockfrost/blockfrost-js\n@jpg-store/lucid-cardano\n@mikro-orm/core\n@mikro-orm/knex\n@prisma/client\n@sentry/nextjs\n@sentry/node\n@swc/core\nargon2", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/serverComponentsExternalPackages"}
{"id": "3c908699141c-1", "text": "@sentry/nextjs\n@sentry/node\n@swc/core\nargon2\nautoprefixer\naws-crt\nbcrypt\nbetter-sqlite3\ncanvas\ncpu-features\ncypress\neslint\nexpress\nfirebase-admin\njest\njsdom\nlodash\nmdx-bundler\nmongodb\nmongoose\nnext-mdx-remote\nnext-seo\npayload\npg\nplaywright\npostcss\nprettier\nprisma\npuppeteer\nrimraf\nsharp\nshiki\nsqlite3\ntailwindcss\nts-node\ntypescript\nvscode-oniguruma\nwebpack", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/serverComponentsExternalPackages"}
{"id": "81dc5b631b23-0", "text": "trailingSlash\nBy default Next.js will redirect urls with trailing slashes to their counterpart without a trailing slash. For example /about/ will redirect to /about. You can configure this behavior to act the opposite way, where urls without trailing slashes are redirected to their counterparts with trailing slashes.\nOpen next.config.js and add the trailingSlash config:\nnext.config.js module.exports = {\n  trailingSlash: true,\n}\nWith this option set, urls like /about will redirect to /about/.\nVersion History\nVersionChangesv9.5.0trailingSlash added.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/trailingSlash"}
{"id": "859f8a377ecb-0", "text": "transpilePackages\nNext.js can automatically transpile and bundle dependencies from local packages (like monorepos) or from external dependencies (node_modules). This replaces the next-transpile-modules package.\nnext.config.js /** @type {import('next').NextConfig} */\nconst nextConfig = {\n  transpilePackages: ['@acme/ui', 'lodash-es'],\n}\n \nmodule.exports = nextConfig\nVersion History\nVersionChangesv13.0.0transpilePackages added.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/transpilePackages"}
{"id": "beff6c4914e2-0", "text": "turbo (Experimental)\nWarning: These features are experimental and will only work with next --turbo.\nwebpack loaders\nCurrently, Turbopack supports a subset of webpack's loader API, allowing you to use some webpack loaders to transform code in Turbopack.\nTo configure loaders, add the names of the loaders you've installed and any options in next.config.js, mapping file extensions to a list of loaders:\nnext.config.js module.exports = {\n  experimental: {\n    turbo: {\n      loaders: {\n        // Option format\n        '.md': [\n          {\n            loader: '@mdx-js/loader',\n            options: {\n              format: 'md',\n            },\n          },\n        ],\n        // Option-less format\n        '.mdx': ['@mdx-js/loader'],\n      },\n    },\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/turbo"}
{"id": "beff6c4914e2-1", "text": "},\n    },\n  },\n}\nThen, given the above configuration, you can use transformed code from your app:\n import MyDoc from './my-doc.mdx'\n \nexport default function Home() {\n  return <MyDoc />\n}\nResolve Alias\nThrough next.config.js, Turbopack can be configured to modify module resolution through aliases, similar to webpack's resolve.alias configuration.\nTo configure resolve aliases, map imported patterns to their new destination in next.config.js:\nnext.config.js module.exports = {\n  experimental: {\n    turbo: {\n      resolveAlias: {\n        underscore: 'lodash',\n        mocha: { browser: 'mocha/browser-entry.js' },\n      },\n    },\n  },\n}\nThis aliases imports of the underscore package to the lodash package. In other words, import underscore from 'underscore' will load the lodash module instead of underscore.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/turbo"}
{"id": "beff6c4914e2-2", "text": "Turbopack also supports conditional aliasing through this field, similar to Node.js's conditional exports. At the moment only the browser condition is supported. In the case above, imports of the mocha module will be aliased to mocha/browser-entry.js when Turbopack targets browser environments.\nFor more information and guidance for how to migrate your app to Turbopack from webpack, see Turbopack's documentation on webpack compatibility.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/turbo"}
{"id": "8d7f8e5e9f61-0", "text": "typedRoutes (experimental)Experimental support for statically typed links. This feature requires using the App Router as well as TypeScript in your project.\nnext.config.js /** @type {import('next').NextConfig} */\nconst nextConfig = {\n  experimental: {\n    typedRoutes: true,\n  },\n}\n \nmodule.exports = nextConfig", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/typedRoutes"}
{"id": "78b228e24dd5-0", "text": "typescript\nNext.js fails your production build (next build) when TypeScript errors are present in your project.\nIf you'd like Next.js to dangerously produce production code even when your application has errors, you can disable the built-in type checking step.\nIf disabled, be sure you are running type checks as part of your build or deploy process, otherwise this can be very dangerous.\nOpen next.config.js and enable the ignoreBuildErrors option in the typescript config:\nnext.config.js module.exports = {\n  typescript: {\n    // !! WARN !!\n    // Dangerously allow production builds to successfully complete even if\n    // your project has type errors.\n    // !! WARN !!\n    ignoreBuildErrors: true,\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/typescript"}
{"id": "a4f8f241128b-0", "text": "urlImports\nURL imports are an experimental feature that allows you to import modules directly from external servers (instead of from the local disk).\nWarning: This feature is experimental. Only use domains that you trust to download and execute on your machine. Please exercise\ndiscretion, and caution until the feature is flagged as stable.\nTo opt-in, add the allowed URL prefixes inside next.config.js:\nnext.config.js module.exports = {\n  experimental: {\n    urlImports: ['https://example.com/assets/', 'https://cdn.skypack.dev'],\n  },\n}\nThen, you can import modules directly from URLs:\n import { a, b, c } from 'https://example.com/assets/some/module.js'\nURL Imports can be used everywhere normal package imports can be used.\nSecurity Model", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/urlImports"}
{"id": "a4f8f241128b-1", "text": "URL Imports can be used everywhere normal package imports can be used.\nSecurity Model\nThis feature is being designed with security as the top priority. To start, we added an experimental flag forcing you to explicitly allow the domains you accept URL imports from. We're working to take this further by limiting URL imports to execute in the browser sandbox using the Edge Runtime.\nLockfile\nWhen using URL imports, Next.js will create a next.lock directory containing a lockfile and fetched assets.\nThis directory must be committed to Git, not ignored by .gitignore.\nWhen running next dev, Next.js will download and add all newly discovered URL Imports to your lockfile\nWhen running next build, Next.js will use only the lockfile to build the application for production\nTypically, no network requests are needed and any outdated lockfile will cause the build to fail.\nOne exception is resources that respond with Cache-Control: no-cache.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/urlImports"}
{"id": "a4f8f241128b-2", "text": "One exception is resources that respond with Cache-Control: no-cache.\nThese resources will have a no-cache entry in the lockfile and will always be fetched from the network on each build.\nExamples\nSkypack\n import confetti from 'https://cdn.skypack.dev/canvas-confetti'\nimport { useEffect } from 'react'\n \nexport default () => {\n  useEffect(() => {\n    confetti()\n  })\n  return <p>Hello</p>\n}\nStatic Image Imports\n import Image from 'next/image'\nimport logo from 'https://example.com/assets/logo.png'\n \nexport default () => (\n  <div>\n    <Image src={logo} placeholder=\"blur\" />\n  </div>\n)\nURLs in CSS\n .className {\n  background: url('https://example.com/assets/hero.jpg');\n}\nAsset Imports", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/urlImports"}
{"id": "a4f8f241128b-3", "text": "background: url('https://example.com/assets/hero.jpg');\n}\nAsset Imports\n const logo = new URL('https://example.com/assets/file.txt', import.meta.url)\n \nconsole.log(logo.pathname)\n \n// prints \"/_next/static/media/file.a9727b5d.txt\"", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/urlImports"}
{"id": "6298ffd93b01-0", "text": "Custom Webpack Config\nGood to know: changes to webpack config are not covered by semver so proceed at your own risk\nBefore continuing to add custom webpack configuration to your application make sure Next.js doesn't already support your use-case:\nCSS imports\nCSS modules\nSass/SCSS imports\nSass/SCSS modules\npreact\nSome commonly asked for features are available as plugins:\n@next/mdx\n@next/bundle-analyzer\nIn order to extend our usage of webpack, you can define a function that extends its config inside next.config.js, like so:\nnext.config.js module.exports = {\n  webpack: (\n    config,\n    { buildId, dev, isServer, defaultLoaders, nextRuntime, webpack }\n  ) => {\n    // Important: return the modified config\n    return config\n  },\n}", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/webpack"}
{"id": "6298ffd93b01-1", "text": "// Important: return the modified config\n    return config\n  },\n}\nThe webpack function is executed twice, once for the server and once for the client. This allows you to distinguish between client and server configuration using the isServer property.\nThe second argument to the webpack function is an object with the following properties:\nbuildId: String - The build id, used as a unique identifier between builds\ndev: Boolean - Indicates if the compilation will be done in development\nisServer: Boolean - It's true for server-side compilation, and false for client-side compilation\nnextRuntime: String | undefined - The target runtime for server-side compilation; either \"edge\" or \"nodejs\", it's undefined for client-side compilation.\ndefaultLoaders: Object - Default loaders used internally by Next.js:\nbabel: Object - Default babel-loader configuration\nExample usage of defaultLoaders.babel:\n // Example config for adding a loader that depends on babel-loader", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/webpack"}
{"id": "6298ffd93b01-2", "text": "// Example config for adding a loader that depends on babel-loader\n// This source was taken from the @next/mdx plugin source:\n// https://github.com/vercel/next.js/tree/canary/packages/next-mdx\nmodule.exports = {\n  webpack: (config, options) => {\n    config.module.rules.push({\n      test: /\\.mdx/,\n      use: [\n        options.defaultLoaders.babel,\n        {\n          loader: '@mdx-js/loader',\n          options: pluginOptions.options,\n        },\n      ],\n    })\n \n    return config\n  },\n}\nnextRuntime\nNotice that isServer is true when nextRuntime is \"edge\" or \"nodejs\", nextRuntime \"edge\" is currently for middleware and Server Components in edge runtime only.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/webpack"}
{"id": "a73144f3957d-0", "text": "webVitalsAttribution\nWhen debugging issues related to Web Vitals, it is often helpful if we can pinpoint the source of the problem.\nFor example, in the case of Cumulative Layout Shift (CLS), we might want to know the first element that shifted when the single largest layout shift occurred.\nOr, in the case of Largest Contentful Paint (LCP), we might want to identify the element corresponding to the LCP for the page.\nIf the LCP element is an image, knowing the URL of the image resource can help us locate the asset we need to optimize.\nPinpointing the biggest contributor to the Web Vitals score, aka attribution,\nallows us to obtain more in-depth information like entries for PerformanceEventTiming, PerformanceNavigationTiming and PerformanceResourceTiming.\nAttribution is disabled by default in Next.js but can be enabled per metric by specifying the following in next.config.js.\nnext.config.js experimental: {", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/webVitalsAttribution"}
{"id": "a73144f3957d-1", "text": "next.config.js experimental: {\n  webVitalsAttribution: ['CLS', 'LCP']\n}\nValid attribution values are all web-vitals metrics specified in the NextWebVitalsMetric type.", "source": "https://nextjs.org/docs/app/api-reference/next-config-js/webVitalsAttribution"}