/**@type{import('./$types').PageLoad}*/exportfunction
functionload({ params }:{params:any;}):{post:{title:string;content:string;};}
@type{import('./$types').PageLoad}load({params:anyparams}) {return{
post:{title:string;content:string;}post:{title:stringtitle:`Title for${params:anyparams.slug}goes here`,content:stringcontent:`Content for${params:anyparams.slug}goes here`}};}

importtype{
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad}from'./$types';exportconstconstload:PageLoadload:
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad=({params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams})=>{return{
post:{title:string;content:string;}post:{title:stringtitle:`Title for${params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams.slug}goes here`,content:stringcontent:`Content for${params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams.slug}goes here`}};};

<script>/**@type{import('./$types').PageProps}*/let{ data }=$props();</script><h1>{data.post.title}</h1><div>{@htmldata.post.content}</div>

<scriptlang="ts">importtype{ PageProps }from'./$types';let{ data }:PageProps=$props();</script><h1>{data.post.title}</h1><div>{@htmldata.post.content}</div>

import*asmodule"$lib/server/database"dbfrom'$lib/server/database';/**@type{import('./$types').PageServerLoad}*/exportasyncfunctionfunctionload(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>):MaybePromise<void|Record<string,any>>
@type{import('./$types').PageServerLoad}load({params:Record<string,any>
The parameters of the current route - e.g. for a route like/blog/[slug], a{ slug: string } object.params}) {return{
post:{title:string;content:string;}post:awaitmodule"$lib/server/database"db.
functiongetPost(slug:string):Promise<{title:string;content:string;}>getPost(params:Record<string,any>
The parameters of the current route - e.g. for a route like/blog/[slug], a{ slug: string } object.params.slug)};}

import*asmodule"$lib/server/database"dbfrom'$lib/server/database';importtype{typePageServerLoad=(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageServerLoad}from'./$types';exportconstconstload:PageServerLoadload:typePageServerLoad=(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageServerLoad=async({params:Record<string,any>
The parameters of the current route - e.g. for a route like/blog/[slug], a{ slug: string } object.params})=>{return{
post:{title:string;content:string;}post:awaitmodule"$lib/server/database"db.
functiongetPost(slug:string):Promise<{title:string;content:string;}>getPost(params:Record<string,any>
The parameters of the current route - e.g. for a route like/blog/[slug], a{ slug: string } object.params.slug)};};

import*asmodule"$lib/server/database"dbfrom'$lib/server/database';/**@type{import('./$types').LayoutServerLoad}*/exportasyncfunctionfunctionload(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>):MaybePromise<void|Record<string,any>>
@type{import('./$types').LayoutServerLoad}load() {return{
posts:{title:string;slug:string;}[]posts:awaitmodule"$lib/server/database"db.
functiongetPostSummaries():Promise<Array<{title:string;slug:string;}>>getPostSummaries()};}

import*asmodule"$lib/server/database"dbfrom'$lib/server/database';importtype{typeLayoutServerLoad=(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutServerLoad}from'./$types';exportconstconstload:LayoutServerLoadload:typeLayoutServerLoad=(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutServerLoad=async()=>{return{
posts:{title:string;slug:string;}[]posts:awaitmodule"$lib/server/database"db.
functiongetPostSummaries():Promise<Array<{title:string;slug:string;}>>getPostSummaries()};};

<script>/**@type{import('./$types').LayoutProps}*/let{ data,children }=$props();</script><main><!-- +page.svelte is `@render`ed here -->{@renderchildren()}</main><aside><h2>More posts</h2><ul>{#eachdata.postsaspost}<li><ahref="/blog/{post.slug}">{post.title}</a></li>{/each}</ul></aside>

<scriptlang="ts">importtype{ LayoutProps }from'./$types';let{ data,children }:LayoutProps=$props();</script><main><!-- +page.svelte is `@render`ed here -->{@renderchildren()}</main><aside><h2>More posts</h2><ul>{#eachdata.postsaspost}<li><ahref="/blog/{post.slug}">{post.title}</a></li>{/each}</ul></aside>

<script>import{ page }from'$app/state';/**@type{import('./$types').PageProps}*/let{ data }=$props();// we can access `data.posts` because it's returned from// the parent layout `load` functionletindex=$derived(data.posts.findIndex(post=>post.slug===page.params.slug));letnext=$derived(data.posts[index+1]);</script><h1>{data.post.title}</h1><div>{@htmldata.post.content}</div>{#ifnext}<p>Next post: <ahref="/blog/{next.slug}">{next.title}</a></p>{/if}

<scriptlang="ts">import{ page }from'$app/state';importtype{ PageProps }from'./$types';let{ data }:PageProps=$props();// we can access `data.posts` because it's returned from// the parent layout `load` functionletindex=$derived(data.posts.findIndex(post=>post.slug===page.params.slug));letnext=$derived(data.posts[index+1]);</script><h1>{data.post.title}</h1><div>{@htmldata.post.content}</div>{#ifnext}<p>Next post: <ahref="/blog/{next.slug}">{next.title}</a></p>{/if}

<script>import{ page }from'$app/state';</script><svelte:head><title>{page.data.title}</title></svelte:head>

<scriptlang="ts">import{ page }from'$app/state';</script><svelte:head><title>{page.data.title}</title></svelte:head>

/**@type{import('./$types').PageServerLoad}*/exportasyncfunction
functionload():Promise<{serverMessage:string;}>
@type{import('./$types').PageServerLoad}load() {return{serverMessage:stringserverMessage:'hello from server load function'};}

importtype{
typePageServerLoad=(event:Kit.ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageServerLoad=(event:Kit.ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageServerLoad}from'./$types';exportconstconstload:PageServerLoadload:
typePageServerLoad=(event:Kit.ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageServerLoad=(event:Kit.ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageServerLoad=async()=>{return{serverMessage:stringserverMessage:'hello from server load function'};};

/**@type{import('./$types').PageLoad}*/exportasyncfunction
functionload({ data }:{data:any;}):Promise<{serverMessage:any;universalMessage:string;}>
@type{import('./$types').PageLoad}load({data:anydata}) {return{serverMessage:anyserverMessage:data:anydata.serverMessage,universalMessage:stringuniversalMessage:'hello from universal load function'};}

importtype{
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad}from'./$types';exportconstconstload:PageLoadload:
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad=async({data:Record<string,any>|null
Contains the data returned by the route’s serverload function (in+layout.server.js or+page.server.js), if any.data})=>{return{serverMessage:anyserverMessage:data:Record<string,any>|null
Contains the data returned by the route’s serverload function (in+layout.server.js or+page.server.js), if any.data.serverMessage,universalMessage:stringuniversalMessage:'hello from universal load function'};};

/**@type{import('./$types').PageLoad}*/exportfunction
functionload({ route }:{route:any;}):void
@type{import('./$types').PageLoad}load({route:anyroute}) {varconsole:Console
Theconsole module provides a simple debugging console that is similar to theJavaScript console mechanism provided by web browsers.
The module exports two specific components:
AConsole class with methods such asconsole.log(),console.error() andconsole.warn() that can be used to write to any Node.js stream.
A globalconsole instance configured to write toprocess.stdout andprocess.stderr. The globalconsole can be used without importing thenode:console module.
Warning: The global console object’s methods are neither consistentlysynchronous like the browser APIs they resemble, nor are they consistentlyasynchronous like all other Node.js streams. See thenote on process I/O formore information.
Example using the globalconsole:
console.log('hello world');// Prints: hello world, to stdoutconsole.log('hello %s','world');// Prints: hello world, to stdoutconsole.error(newError('Whoops, something bad happened'));// Prints error message and stack trace to stderr://   Error: Whoops, something bad happened//     at [eval]:5:15//     at Script.runInThisContext (node:vm:132:18)//     at Object.runInThisContext (node:vm:309:38)//     at node:internal/process/execution:77:19//     at [eval]-wrapper:6:22//     at evalScript (node:internal/process/execution:76:60)//     at node:internal/main/eval_string:23:3constname='Will Robinson';console.warn(`Danger${name}! Danger!`);// Prints: Danger Will Robinson! Danger!, to stderr
Example using theConsole class:
constout=getStreamSomehow();consterr=getStreamSomehow();constmyConsole=newconsole.Console(out,err);myConsole.log('hello world');// Prints: hello world, to outmyConsole.log('hello %s','world');// Prints: hello world, to outmyConsole.error(newError('Whoops, something bad happened'));// Prints: [Error: Whoops, something bad happened], to errconstname='Will Robinson';myConsole.warn(`Danger${name}! Danger!`);// Prints: Danger Will Robinson! Danger!, to err
@seesourceconsole.Console.log(message?:any,...optionalParams: any[]):void(+1overload)
Prints tostdout with newline. Multiple arguments can be passed, with thefirst used as the primary message and all additional used as substitutionvalues similar toprintf(3)(the arguments are all passed toutil.format()).
constcount=5;console.log('count: %d',count);// Prints: count: 5, to stdoutconsole.log('count:',count);// Prints: count: 5, to stdout
Seeutil.format() for more information.
@sincev0.1.100log(route:anyroute.id);// '/a/[b]/[...c]'}

importtype{
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad}from'./$types';exportconstconstload:PageLoadload:
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad=({
route:{id:string|null;}
Info about the current routeroute})=>{varconsole:Console
Theconsole module provides a simple debugging console that is similar to theJavaScript console mechanism provided by web browsers.
The module exports two specific components:
AConsole class with methods such asconsole.log(),console.error() andconsole.warn() that can be used to write to any Node.js stream.
A globalconsole instance configured to write toprocess.stdout andprocess.stderr. The globalconsole can be used without importing thenode:console module.
Warning: The global console object’s methods are neither consistentlysynchronous like the browser APIs they resemble, nor are they consistentlyasynchronous like all other Node.js streams. See thenote on process I/O formore information.
Example using the globalconsole:
console.log('hello world');// Prints: hello world, to stdoutconsole.log('hello %s','world');// Prints: hello world, to stdoutconsole.error(newError('Whoops, something bad happened'));// Prints error message and stack trace to stderr://   Error: Whoops, something bad happened//     at [eval]:5:15//     at Script.runInThisContext (node:vm:132:18)//     at Object.runInThisContext (node:vm:309:38)//     at node:internal/process/execution:77:19//     at [eval]-wrapper:6:22//     at evalScript (node:internal/process/execution:76:60)//     at node:internal/main/eval_string:23:3constname='Will Robinson';console.warn(`Danger${name}! Danger!`);// Prints: Danger Will Robinson! Danger!, to stderr
Example using theConsole class:
constout=getStreamSomehow();consterr=getStreamSomehow();constmyConsole=newconsole.Console(out,err);myConsole.log('hello world');// Prints: hello world, to outmyConsole.log('hello %s','world');// Prints: hello world, to outmyConsole.error(newError('Whoops, something bad happened'));// Prints: [Error: Whoops, something bad happened], to errconstname='Will Robinson';myConsole.warn(`Danger${name}! Danger!`);// Prints: Danger Will Robinson! Danger!, to err
@seesourceconsole.Console.log(message?:any,...optionalParams: any[]):void(+1overload)
Prints tostdout with newline. Multiple arguments can be passed, with thefirst used as the primary message and all additional used as substitutionvalues similar toprintf(3)(the arguments are all passed toutil.format()).
constcount=5;console.log('count: %d',count);// Prints: count: 5, to stdoutconsole.log('count:',count);// Prints: count: 5, to stdout
Seeutil.format() for more information.
@sincev0.1.100log(
route:{id:string|null;}
Info about the current routeroute.id:string|null
The ID of the current route - e.g. forsrc/routes/blog/[slug], it would be/blog/[slug]. It isnull when no route is matched.id);// '/a/[b]/[...c]'};

{"b": "x","c": "y/z"}

/**@type{import('./$types').PageLoad}*/exportasyncfunction
functionload({ fetch,params }:{fetch:any;params:any;}):Promise<{item:any;}>
@type{import('./$types').PageLoad}load({fetch:anyfetch,params:anyparams}) {constconstres:anyres=awaitfetch:anyfetch(`/api/items/${params:anyparams.id}`);constconstitem:anyitem=awaitconstres:anyres.json();return{item:anyitem};}

importtype{
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad}from'./$types';exportconstconstload:PageLoadload:
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad=async({
fetch:{(input:RequestInfo|URL,init?:RequestInit):Promise<Response>;(input:string|URL|globalThis.Request,init?:RequestInit):Promise<Response>;}
fetch is equivalent to thenativefetch web API, with a few additional features:
It can be used to make credentialed requests on the server, as it inherits thecookie andauthorization headers for the page request.
It can make relative requests on the server (ordinarily,fetch requires a URL with an origin when used in a server context).
Internal requests (e.g. for+server.js routes) go directly to the handler function when running on the server, without the overhead of an HTTP call.
During server-side rendering, the response will be captured and inlined into the rendered HTML by hooking into thetext andjson methods of theResponse object. Note that headers willnot be serialized, unless explicitly included viafilterSerializedResponseHeaders
During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
You can learn more about making credentialed requests with cookiesherefetch,params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams})=>{constconstres:Responseres=awaitfetch:(input:string|URL|globalThis.Request,init?:RequestInit)=>Promise<Response> (+1overload)
MDN Referencefetch(`/api/items/${params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams.id}`);constconstitem:anyitem=awaitconstres:Responseres.Body.json():Promise<any>
MDN Referencejson();return{item:anyitem};};

import*asmodule"$lib/server/database"dbfrom'$lib/server/database';/**@type{import('./$types').LayoutServerLoad}*/exportasyncfunctionfunctionload(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>):MaybePromise<void|Record<string,any>>
@type{import('./$types').LayoutServerLoad}load({cookies:Cookies
Get or set cookies related to the current requestcookies}) {constconstsessionid:string|undefinedsessionid=cookies:Cookies
Get or set cookies related to the current requestcookies.Cookies.get: (name:string,opts?:CookieParseOptions)=>string|undefined
Gets a cookie that was previously set withcookies.set, or from the request headers.
@paramname the name of the cookie
@paramopts the options, passed directly tocookie.parse. See documentationhereget('sessionid');return{
user:{name:string;avatar:string;}user:awaitmodule"$lib/server/database"db.
functiongetUser(sessionid:string|undefined):Promise<{name:string;avatar:string;}>getUser(constsessionid:string|undefinedsessionid)};}

import*asmodule"$lib/server/database"dbfrom'$lib/server/database';importtype{typeLayoutServerLoad=(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutServerLoad}from'./$types';exportconstconstload:LayoutServerLoadload:typeLayoutServerLoad=(event:ServerLoadEvent<Record<string,any>,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutServerLoad=async({cookies:Cookies
Get or set cookies related to the current requestcookies})=>{constconstsessionid:string|undefinedsessionid=cookies:Cookies
Get or set cookies related to the current requestcookies.Cookies.get: (name:string,opts?:CookieParseOptions)=>string|undefined
Gets a cookie that was previously set withcookies.set, or from the request headers.
@paramname the name of the cookie
@paramopts the options, passed directly tocookie.parse. See documentationhereget('sessionid');return{
user:{name:string;avatar:string;}user:awaitmodule"$lib/server/database"db.
functiongetUser(sessionid:string|undefined):Promise<{name:string;avatar:string;}>getUser(constsessionid:string|undefinedsessionid)};};

/**@type{import('./$types').PageLoad}*/exportasyncfunction
functionload({ fetch,setHeaders }:{fetch:any;setHeaders:any;}):Promise<any>
@type{import('./$types').PageLoad}load({fetch:anyfetch,setHeaders:anysetHeaders}) {constconsturl:"https://cms.example.com/products.json"url=`https://cms.example.com/products.json`;constconstresponse:anyresponse=awaitfetch:anyfetch(consturl:"https://cms.example.com/products.json"url);// Headers are only set during SSR, caching the page's HTML// for the same length of time as the underlying data.setHeaders:anysetHeaders({age:anyage:constresponse:anyresponse.headers.get('age'),'cache-control':constresponse:anyresponse.headers.get('cache-control')});returnconstresponse:anyresponse.json();}

importtype{
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad}from'./$types';exportconstconstload:PageLoadload:
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad=async({
fetch:{(input:RequestInfo|URL,init?:RequestInit):Promise<Response>;(input:string|URL|globalThis.Request,init?:RequestInit):Promise<Response>;}
fetch is equivalent to thenativefetch web API, with a few additional features:
It can be used to make credentialed requests on the server, as it inherits thecookie andauthorization headers for the page request.
It can make relative requests on the server (ordinarily,fetch requires a URL with an origin when used in a server context).
Internal requests (e.g. for+server.js routes) go directly to the handler function when running on the server, without the overhead of an HTTP call.
During server-side rendering, the response will be captured and inlined into the rendered HTML by hooking into thetext andjson methods of theResponse object. Note that headers willnot be serialized, unless explicitly included viafilterSerializedResponseHeaders
During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
You can learn more about making credentialed requests with cookiesherefetch,setHeaders:(headers:Record<string,string>)=>void
If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
src/routes/blog/+page
exportasyncfunctionload({ fetch,setHeaders }) {consturl=`https://cms.example.com/articles.json`;constresponse=awaitfetch(url);setHeaders({age:response.headers.get('age'),'cache-control':response.headers.get('cache-control')});returnresponse.json();}
Setting the same header multiple times (even in separateload functions) is an error — you can only set a given header once.
You cannot add aset-cookie header withsetHeaders — use thecookies API in a server-onlyload function instead.
setHeaders has no effect when aload function runs in the browser.setHeaders})=>{constconsturl:"https://cms.example.com/products.json"url=`https://cms.example.com/products.json`;constconstresponse:Responseresponse=awaitfetch:(input:string|URL|globalThis.Request,init?:RequestInit)=>Promise<Response> (+1overload)
MDN Referencefetch(consturl:"https://cms.example.com/products.json"url);// Headers are only set during SSR, caching the page's HTML// for the same length of time as the underlying data.setHeaders:(headers:Record<string,string>)=>void
If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
src/routes/blog/+page
exportasyncfunctionload({ fetch,setHeaders }) {consturl=`https://cms.example.com/articles.json`;constresponse=awaitfetch(url);setHeaders({age:response.headers.get('age'),'cache-control':response.headers.get('cache-control')});returnresponse.json();}
Setting the same header multiple times (even in separateload functions) is an error — you can only set a given header once.
You cannot add aset-cookie header withsetHeaders — use thecookies API in a server-onlyload function instead.
setHeaders has no effect when aload function runs in the browser.setHeaders({age:string|nullage:constresponse:Responseresponse.Response.headers: Headers
MDN Referenceheaders.Headers.get(name: string): string|null
MDN Referenceget('age'),'cache-control':constresponse:Responseresponse.Response.headers: Headers
MDN Referenceheaders.Headers.get(name: string): string|null
MDN Referenceget('cache-control')});returnconstresponse:Responseresponse.Body.json():Promise<any>
MDN Referencejson();};

/**@type{import('./$types').LayoutLoad}*/exportfunction
functionload():{a:number;}
@type{import('./$types').LayoutLoad}load() {return{a:numbera:1};}

importtype{
typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutLoad}from'./$types';exportconstconstload:LayoutLoadload:
typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutLoad=()=>{return{a:numbera:1};};

/**@type{import('./$types').LayoutLoad}*/exportasyncfunction
functionload({ parent }:{parent:any;}):Promise<{b:any;}>
@type{import('./$types').LayoutLoad}load({parent:anyparent}) {const{consta:anya}=awaitparent:anyparent();return{b:anyb:consta:anya+1};}

importtype{
typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutLoad}from'./$types';exportconstconstload:LayoutLoadload:
typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typeLayoutLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>LayoutLoad=async({parent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent})=>{const{consta:anya}=awaitparent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent();return{b:anyb:consta:anya+1};};

/**@type{import('./$types').PageLoad}*/exportasyncfunction
functionload({ parent }:{parent:any;}):Promise<{c:any;}>
@type{import('./$types').PageLoad}load({parent:anyparent}) {const{consta:anya,constb:anyb}=awaitparent:anyparent();return{c:anyc:consta:anya+constb:anyb};}

importtype{
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad}from'./$types';exportconstconstload:PageLoadload:
typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>typePageLoad=(event:Kit.LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad=async({parent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent})=>{const{consta:anya,constb:anyb}=awaitparent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent();return{c:anyc:consta:anya+constb:anyb};};

<script>/**@type{import('./$types').PageProps}*/let{ data }=$props();</script><!-- renders `1 + 2 = 3` --><p>{data.a} + {data.b} = {data.c}</p>

<scriptlang="ts">importtype{ PageProps }from'./$types';let{ data }:PageProps=$props();</script><!-- renders `1 + 2 = 3` --><p>{data.a} + {data.b} = {data.c}</p>

/**@type{import('./$types').PageLoad}*/exportasyncfunctionfunctionload(event:LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>):MaybePromise<void|Record<string,any>>
@type{import('./$types').PageLoad}load({params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams,parent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent}) {const parentData = await parent();const
constdata:{meta:any;}data=await
functiongetData(params:Record<string,string>):Promise<{meta:any;}>getData(params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams);constconstparentData:Record<string,any>parentData=awaitparent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent();return{...
constdata:{meta:any;}data,meta:anymeta:{...constparentData:Record<string,any>parentData.meta,...
constdata:{meta:any;}data.meta:anymeta}};}

importtype{typePageLoad=(event:LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad}from'./$types';exportconstconstload:PageLoadload:typePageLoad=(event:LoadEvent<Record<string,any>,Record<string,any>|null,Record<string,any>,string|null>)=>MaybePromise<void|Record<string,any>>PageLoad=async({params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams,parent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent})=>{const parentData = await parent();const
constdata:{meta:any;}data=await
functiongetData(params:Record<string,string>):Promise<{meta:any;}>getData(params:Record<string,any>
The parameters of the current page - e.g. for a route like/blog/[slug], a{ slug: string } objectparams);constconstparentData:Record<string,any>parentData=awaitparent:()=>Promise<Record<string,any>>
await parent() returns data from parent+layout.jsload functions.Implicitly, a missing+layout.js is treated as a({ data }) => data function, meaning that it will return and forward data from parent+layout.server.js files.
Be careful not to introduce accidental waterfalls when usingawait parent(). If for example you only want to merge parent data into the returned output, call itafter fetching your other data.parent();return{...
constdata:{meta:any;}data,meta:anymeta:{...constparentData:Record<string,any>parentData.meta,...
constdata:{meta:any;}data.meta:anymeta}};};