Layout load functions in Svelte

Introduction

Layout load functions help you get data before showing a page layout. This makes sure your page has what it needs right away.

When you want to fetch user info once and use it on many pages.

When you need to load settings or theme data for the whole app layout.

When you want to show a loading state while data is being fetched for the layout.

When you want to share data between nested pages without refetching.

When you want to protect routes by checking user login status before showing the layout.

Syntax

Svelte

export async function load({ fetch, params, url }) {
  // fetch or prepare data here
  return {
    key: value
  };
}

The load function runs before the layout renders.

It returns an object whose properties become available in the layout component.

Examples

Simple load function returning a title prop for the layout.

Svelte

export async function load() {
  return {
    title: 'Welcome to My Site'
  };
}

Load function fetching user data from an API to pass to the layout.

Svelte

export async function load({ fetch }) {
  const res = await fetch('/api/user');
  const user = await res.json();
  return {
    user
  };
}

Load function reading query parameter to set language prop.

Svelte

export async function load({ url }) {
  const lang = url.searchParams.get('lang') || 'en';
  return {
    lang
  };
}

Sample Program

This example shows a load function in +layout.js providing a greeting message to +layout.svelte before rendering. The greeting is shown in the header.

Svelte

<!-- +layout.js -->
export async function load() {
  return {
    greeting: 'Hello from layout load!'
  };
}

<!-- +layout.svelte -->
<script>
  export let data;
</script>

<header>
  <h1>{data.greeting}</h1>
</header>

<slot />

Important Notes

Layout load functions run on both server and client during navigation.

Returned properties are reactive and update the layout when changed.

Use fetch inside load to get data safely with SvelteKit's routing.

Summary

Layout load functions fetch or prepare data before the layout shows.

They return an object whose properties the layout component can use.

This helps share data across pages and improve user experience.

Practice

1. What is the main purpose of a load function in a Svelte layout?

easy

A. To style the layout component with CSS

B. To fetch or prepare data before the layout renders

C. To handle user events like clicks

D. To define routes for the application

Solution

1. Step 1: Understand the role of load functions in Svelte layouts

   Load functions run before the layout renders to get data ready.

2. Step 2: Identify what load functions do

   They fetch or prepare data so the layout can use it immediately.

3. Final Answer:

   To fetch or prepare data before the layout renders -> Option B

4. Quick Check:

   Layout load = fetch data before render [OK]

Hint: Load functions prepare data before layout shows [OK]

Common Mistakes:

• Confusing load with styling or event handling
• Thinking load defines routes
• Assuming load runs after layout renders

2. Which of the following is the correct syntax for a layout load function in SvelteKit?

easy

A. export async function load() { return { user: 'Alice' }; }

B. export async function load() { return { props: { user: 'Alice' } }; }

C. export function load() { return { props: { user: 'Alice' } }; }

D. function load() { return { user: 'Alice' }; }

Solution

1. Step 1: Recall the modern SvelteKit load function syntax

   Load functions are async and return data directly, not inside a props object.

2. Step 2: Check each option's return value

   export async function load() { return { user: 'Alice' }; } returns { user: 'Alice' } directly, which is correct for layout load.

3. Final Answer:

   export async function load() { return { user: 'Alice' }; } -> Option A

4. Quick Check:

   Load returns data directly, no props wrapper [OK]

Hint: Load returns data directly, no props wrapper [OK]

Common Mistakes:

• Returning data inside a props object (old pattern)
• Missing async keyword
• Not exporting the load function

3. Given this layout load function:

export async function load() {
  return { user: 'Bob', theme: 'dark' };
}

What data will be available in the layout component's data prop?

medium

A. { user: 'Bob', theme: 'dark' }

B. { props: { user: 'Bob', theme: 'dark' } }

C. undefined

D. { user: 'Bob' }

Solution

1. Step 1: Understand what the load function returns

   The load function returns an object with keys user and theme.

2. Step 2: Know how layout receives load data

   The layout component receives the returned object as its data prop directly.

3. Final Answer:

   { user: 'Bob', theme: 'dark' } -> Option A

4. Quick Check:

   Load return = layout data prop [OK]

Hint: Layout data matches load return object exactly [OK]

Common Mistakes:

• Expecting data inside a props object
• Assuming data is undefined without explicit props
• Only partial data returned

4. Identify the error in this layout load function:

export function load() {
  const user = fetch('/api/user');
  return { user };
}

medium

A. load function should not return any value

B. Returning user inside an object is incorrect

C. fetch should not be used in load functions

D. Missing async keyword and await for fetch

Solution

1. Step 1: Check if fetch is awaited

   fetch returns a promise, so it must be awaited inside an async function.

2. Step 2: Verify load function declaration

   load must be async to use await; here it is missing async.

3. Final Answer:

   Missing async keyword and await for fetch -> Option D

4. Quick Check:

   Async + await needed for fetch in load [OK]

Hint: Always use async and await with fetch in load [OK]

Common Mistakes:

• Forgetting async keyword
• Not awaiting fetch promise
• Returning unresolved promise instead of data

5. You want to share user info fetched in a layout load function with all nested pages. Which approach correctly achieves this in SvelteKit?

hard

A. Store user data in a global variable outside load functions

B. Fetch user data separately in each page's load function

C. Use a layout load function that fetches user data and returns it; nested pages access via data

D. Pass user data as props manually from layout to pages

Solution

1. Step 1: Understand data flow in SvelteKit layouts

   Layout load functions run once and share data with nested pages via the data prop.

2. Step 2: Identify best practice for shared data

   Fetching user data in layout load and returning it allows nested pages to access it automatically.

3. Final Answer:

   Use a layout load function that fetches user data and returns it; nested pages access via data -> Option C

4. Quick Check:

   Layout load shares data with nested pages [OK]

Hint: Fetch once in layout load to share data with pages [OK]

Common Mistakes:

• Fetching data repeatedly in each page
• Using global variables causing stale data
• Manually passing props instead of using data prop