Runtime

Svelte

The svelte package exposes lifecycle functions and the context API.

# onMount

        onMount(callback: () => void)

      

        onMount(callback: () => () => void)

      

The onMount function schedules a callback to run as soon as the component has been mounted to the DOM. It must be called during the component's initialisation (but doesn't need to live inside the component; it can be called from an external module).

onMount does not run inside a server-side component.

        <script>
	import { onMount } from 'svelte';

	onMount(() => {
		console.log('the component has mounted');
	});
</script>

      

If a function is returned from onMount, it will be called when the component is unmounted.

        <script>
	import { onMount } from 'svelte';

	onMount(() => {
		const interval = setInterval(() => {
			console.log('beep');
		}, 1000);

		return () => clearInterval(interval);
	});
</script>

      

# beforeUpdate

        beforeUpdate(callback: () => void)

      

Schedules a callback to run immediately before the component is updated after any state change.

        <script>
	import { beforeUpdate } from 'svelte';

	beforeUpdate(() => {
		console.log('the component is about to update');
	});
</script>

      

# afterUpdate

        afterUpdate(callback: () => void)

      

Schedules a callback to run immediately after the component has been updated.

        <script>
	import { afterUpdate } from 'svelte';

	afterUpdate(() => {
		console.log('the component just updated');
	});
</script>

      

# onDestroy

        onDestroy(callback: () => void)

      

Schedules a callback to run immediately before the component is unmounted.

Out of onMount, beforeUpdate, afterUpdate and onDestroy, this is the only one that runs inside a server-side component.

        <script>
	import { onDestroy } from 'svelte';

	onDestroy(() => {
		console.log('the component is being destroyed');
	});
</script>

      

# tick

        promise: Promise = tick();

      

Returns a promise that resolves once any pending state changes have been applied, or in the next microtask if there are none.

        <script>
	import { beforeUpdate, tick } from 'svelte';

	beforeUpdate(async () => {
		console.log('the component is about to update');
		await tick();
		console.log('the component just updated');
	});
</script>

      

# setContext

        setContext(key: any, context: any)

      

Associates an arbitrary context object with the current component and the specified key. The context is then available to children of the component (including slotted content) with getContext.

Like lifecycle functions, this must be called during component initialisation.

        <script>
	import { setContext } from 'svelte';

	setContext('answer', 42);
</script>

      

# getContext

        context: any = getContext(key: any)

      

Retrieves the context that belongs to the closest parent component with the specified key. Must be called during component initialisation.

        <script>
	import { getContext } from 'svelte';

	const answer = getContext('answer');
</script>

      

# hasContext

        hasContext: boolean = hasContext(key: any)

      

Checks whether a given key has been set in the context of a parent component. Must be called during component initialisation.

        <script>
	import { hasContext } from 'svelte';

	if (hasContext('answer')) {
		// do something
	}
</script>

      

# getAllContexts

        contexts: Map<any, any> = getAllContexts()

      

Retrieves the whole context map that belongs to the closest parent component. Must be called during component initialisation. Useful, for example, if you programmatically create a component and want to pass the existing context to it.

        <script>
	import { getAllContexts } from 'svelte';

	const contexts = getAllContexts();
</script>

      

# createEventDispatcher

        dispatch: ((name: string, detail?: any) => void) = createEventDispatcher();

      

Creates an event dispatcher that can be used to dispatch component events. Event dispatchers are functions that can take two arguments: name and detail.

Component events created with createEventDispatcher create a CustomEvent. These events do not bubble and are not cancellable with event.preventDefault(). The detail argument corresponds to the CustomEvent.detail property and can contain any type of data.

        <script>
	import { createEventDispatcher } from 'svelte';

	const dispatch = createEventDispatcher();
</script>

<button on:click="{() => dispatch('notify', 'detail value')}">Fire Event</button>

      

Events dispatched from child components can be listened to in their parent. Any data provided when the event was dispatched is available on the detail property of the event object.

        <script>
	function callbackFunction(event) {
		console.log(`Notify fired! Detail: ${event.detail}`)
	}
</script>

<Child on:notify="{callbackFunction}"/>