<script setup>​

<script setup> is a compile-time syntactic sugar for using Composition API inside Single-File Components (SFCs). It is the recommended syntax if you are using both SFCs and Composition API. It provides a number of advantages over the normal<script> syntax:

• More succinct code with less boilerplate
• Ability to declare props and emitted events using pure TypeScript
• Better runtime performance (the template is compiled into a render function in the same scope, without an intermediate proxy)
• Better IDE type-inference performance (less work for the language server to extract types from code)

Basic Syntax​

To opt-in to the syntax, add thesetup attribute to the<script> block:

<script setup>console.log('hello script setup')</script>

The code inside is compiled as the content of the component'ssetup() function. This means that unlike normal<script>, which only executes once when the component is first imported, code inside<script setup> willexecute every time an instance of the component is created.

Top-level bindings are exposed to template​

When using<script setup>, any top-level bindings (including variables, function declarations, and imports) declared inside<script setup> are directly usable in the template:

<script setup>// variableconst msg = 'Hello!'// functionsfunction log() {  console.log(msg)}</script><template>  <button @click="log">{{ msg }}</button></template>

Imports are exposed in the same fashion. This means you can directly use an imported helper function in template expressions without having to expose it via themethods option:

<script setup>import { capitalize }from './helpers'</script><template>  <div>{{ capitalize('hello') }}</div></template>

Reactivity​

Reactive state needs to be explicitly created usingReactivity APIs. Similar to values returned from asetup() function, refs are automatically unwrapped when referenced in templates:

<script setup>import { ref }from 'vue'const count = ref(0)</script><template>  <button @click="count++">{{ count }}</button></template>

Using Components​

Values in the scope of<script setup> can also be used directly as custom component tag names:

<script setup>import MyComponentfrom './MyComponent.vue'</script><template>  <MyComponent /></template>

Think ofMyComponent as being referenced as a variable. If you have used JSX, the mental model is similar here. The kebab-case equivalent<my-component> also works in the template - however PascalCase component tags are strongly recommended for consistency. It also helps differentiating from native custom elements.

Dynamic Components​

Since components are referenced as variables instead of registered under string keys, we should use dynamic:is binding when using dynamic components inside<script setup>:

<script setup>import Foofrom './Foo.vue'import Barfrom './Bar.vue'</script><template>  <component :is="Foo" />  <component :is="someCondition ? Foo : Bar" /></template>

Note how the components can be used as variables in a ternary expression.

Recursive Components​

An SFC can implicitly refer to itself via its filename. E.g. a file namedFooBar.vue can refer to itself as<FooBar/> in its template.

Note this has lower priority than imported components. If you have a named import that conflicts with the component's inferred name, you can alias the import:

import { FooBaras FooBarChild }from './components'

Namespaced Components​

You can use component tags with dots like<Foo.Bar> to refer to components nested under object properties. This is useful when you import multiple components from a single file:

<script setup>import * as Formfrom './form-components'</script><template>  <Form.Input>    <Form.Label>label</Form.Label>  </Form.Input></template>

Using Custom Directives​

Globally registered custom directives just work as normal. Local custom directives don't need to be explicitly registered with<script setup>, but they must follow the naming schemevNameOfDirective:

<script setup>const vMyDirective = {  beforeMount: (el)=> {    // do something with the element  }}</script><template>  <h1 v-my-directive>This is a Heading</h1></template>

If you're importing a directive from elsewhere, it can be renamed to fit the required naming scheme:

<script setup>import { myDirectiveas vMyDirective }from './MyDirective.js'</script>

defineProps() & defineEmits()​

To declare options likeprops andemits with full type inference support, we can use thedefineProps anddefineEmits APIs, which are automatically available inside<script setup>:

<script setup>const props = defineProps({  foo: String})const emit = defineEmits(['change','delete'])// setup code</script>

• defineProps anddefineEmits arecompiler macros only usable inside<script setup>. They do not need to be imported, and are compiled away when<script setup> is processed.

• defineProps accepts the same value as theprops option, whiledefineEmits accepts the same value as theemits option.

• defineProps anddefineEmits provide proper type inference based on the options passed.

• The options passed todefineProps anddefineEmits will be hoisted out of setup into module scope. Therefore, the options cannot reference local variables declared in setup scope. Doing so will result in a compile error. However, itcan reference imported bindings since they are in the module scope as well.

Type-only props/emit declarations​

Props and emits can also be declared using pure-type syntax by passing a literal type argument todefineProps ordefineEmits:

const props = defineProps<{  foo: string  bar?: number}>()const emit = defineEmits<{  (e: 'change',id: number): void  (e: 'update',value: string): void}>()// 3.3+: alternative, more succinct syntaxconst emit = defineEmits<{  change: [id:number]// named tuple syntax  update: [value:string]}>()

• defineProps ordefineEmits can only use either runtime declaration OR type declaration. Using both at the same time will result in a compile error.

• When using type declaration, the equivalent runtime declaration is automatically generated from static analysis to remove the need for double declaration and still ensure correct runtime behavior.

  • In dev mode, the compiler will try to infer corresponding runtime validation from the types. For example herefoo: String is inferred from thefoo: string type. If the type is a reference to an imported type, the inferred result will befoo: null (equal toany type) since the compiler does not have information of external files.

  • In prod mode, the compiler will generate the array format declaration to reduce bundle size (the props here will be compiled into['foo', 'bar'])

• In version 3.2 and below, the generic type parameter fordefineProps() were limited to a type literal or a reference to a local interface.

  This limitation has been resolved in 3.3. The latest version of Vue supports referencing imported and a limited set of complex types in the type parameter position. However, because the type to runtime conversion is still AST-based, some complex types that require actual type analysis, e.g. conditional types, are not supported. You can use conditional types for the type of a single prop, but not the entire props object.

Reactive Props Destructure​

In Vue 3.5 and above, variables destructured from the return value ofdefineProps are reactive. Vue's compiler automatically prependsprops. when code in the same<script setup> block accesses variables destructured fromdefineProps:

const {foo }= defineProps(['foo'])watchEffect(()=> {  // runs only once before 3.5  // re-runs when the "foo" prop changes in 3.5+  console.log(foo)})

The above is compiled to the following equivalent:

const props = defineProps(['foo'])watchEffect(()=> {  // `foo` transformed to `props.foo` by the compiler  console.log(props.foo)})

In addition, you can use JavaScript's native default value syntax to declare default values for the props. This is particularly useful when using the type-based props declaration:

interface Props {  msg?: string  labels?: string[]}const {msg = 'hello',labels = ['one','two'] }= defineProps<Props>()

Default props values when using type declaration​

In 3.5 and above, default values can be naturally declared when using Reactive Props Destructure. But in 3.4 and below, Reactive Props Destructure is not enabled by default. In order to declare props default values with type-based declaration, thewithDefaults compiler macro is needed:

interface Props {  msg?: string  labels?: string[]}const props = withDefaults(defineProps<Props>(), {  msg:'hello',  labels: ()=> ['one','two']})

This will be compiled to equivalent runtime propsdefault options. In addition, thewithDefaults helper provides type checks for the default values, and ensures the returnedprops type has the optional flags removed for properties that do have default values declared.

defineModel()​

• Only available in 3.4+

This macro can be used to declare a two-way binding prop that can be consumed viav-model from the parent component. Example usage is also discussed in theComponentv-model guide.

Under the hood, this macro declares a model prop and a corresponding value update event. If the first argument is a literal string, it will be used as the prop name; Otherwise the prop name will default to"modelValue". In both cases, you can also pass an additional object which can include the prop's options and the model ref's value transform options.

// declares "modelValue" prop, consumed by parent via v-modelconst model = defineModel()// OR: declares "modelValue" prop with optionsconst model = defineModel({ type: String })// emits "update:modelValue" when mutatedmodel.value= 'hello'// declares "count" prop, consumed by parent via v-model:countconst count = defineModel('count')// OR: declares "count" prop with optionsconst count = defineModel('count', { type: Number, default:0 })function inc() {  // emits "update:count" when mutated  count.value++}

<script setup>const model = defineModel({ default:1 })</script>

<script setup>const myRef = ref()</script><template>  <Child v-model="myRef"></Child></template>

Modifiers and Transformers​

To access modifiers used with thev-model directive, we can destructure the return value ofdefineModel() like this:

const [modelValue,modelModifiers]= defineModel()// corresponds to v-model.trimif (modelModifiers.trim) {  // ...}

When a modifier is present, we likely need to transform the value when reading or syncing it back to the parent. We can achieve this by using theget andset transformer options:

const [modelValue,modelModifiers]= defineModel({  // get() omitted as it is not needed here  set(value) {    // if the .trim modifier is used, return trimmed value    if (modelModifiers.trim) {      return value.trim()    }    // otherwise, return the value as-is    return value  }})

Usage with TypeScript​

LikedefineProps anddefineEmits,defineModel can also receive type arguments to specify the types of the model value and the modifiers:

const modelValue = defineModel<string>()//    ^? Ref<string | undefined>// default model with options, required removes possible undefined valuesconst modelValue = defineModel<string>({ required:true })//    ^? Ref<string>const [modelValue,modifiers]= defineModel<string,'trim' | 'uppercase'>()//                 ^? Record<'trim' | 'uppercase', true | undefined>

defineExpose()​

Components using<script setup> areclosed by default - i.e. the public instance of the component, which is retrieved via template refs or$parent chains, willnot expose any of the bindings declared inside<script setup>.

To explicitly expose properties in a<script setup> component, use thedefineExpose compiler macro:

<script setup>import { ref }from 'vue'const a = 1const b = ref(2)defineExpose({  a,  b})</script>

When a parent gets an instance of this component via template refs, the retrieved instance will be of the shape{ a: number, b: number } (refs are automatically unwrapped just like on normal instances).

defineOptions()​

• Only supported in 3.3+

This macro can be used to declare component options directly inside<script setup> without having to use a separate<script> block:

<script setup>defineOptions({  inheritAttrs:false,  customOptions: {    /* ... */  }})</script>

• This is a macro. The options will be hoisted to module scope and cannot access local variables in<script setup> that are not literal constants.

defineSlots()​

• Only supported in 3.3+

This macro can be used to provide type hints to IDEs for slot name and props type checking.

defineSlots() only accepts a type parameter and no runtime arguments. The type parameter should be a type literal where the property key is the slot name, and the value type is the slot function. The first argument of the function is the props the slot expects to receive, and its type will be used for slot props in the template. The return type is currently ignored and can beany, but we may leverage it for slot content checking in the future.

It also returns theslots object, which is equivalent to theslots object exposed on the setup context or returned byuseSlots().

<script setup lang="ts">const slots = defineSlots<{  default(props: {msg: string }): any}>()</script>

useSlots() &useAttrs()​

Usage ofslots andattrs inside<script setup> should be relatively rare, since you can access them directly as$slots and$attrs in the template. In the rare case where you do need them, use theuseSlots anduseAttrs helpers respectively:

<script setup>import { useSlots, useAttrs }from 'vue'const slots = useSlots()const attrs = useAttrs()</script>

useSlots anduseAttrs are actual runtime functions that return the equivalent ofsetupContext.slots andsetupContext.attrs. They can be used in normal composition API functions as well.

Usage alongside normal<script>​

<script setup> can be used alongside normal<script>. A normal<script> may be needed in cases where we need to:

• Declare options that cannot be expressed in<script setup>, for exampleinheritAttrs or custom options enabled via plugins (Can be replaced bydefineOptions in 3.3+).
• Declaring named exports.
• Run side effects or create objects that should only execute once.

<script>// normal <script>, executed in module scope (only once)runSideEffectOnce()// declare additional optionsexport default {  inheritAttrs:false,  customOptions: {}}</script><script setup>// executed in setup() scope (for each instance)</script>

Support for combining<script setup> and<script> in the same component is limited to the scenarios described above. Specifically:

• DoNOT use a separate<script> section for options that can already be defined using<script setup>, such asprops andemits.
• Variables created inside<script setup> are not added as properties to the component instance, making them inaccessible from the Options API. Mixing APIs in this way is strongly discouraged.

If you find yourself in one of the scenarios that is not supported then you should consider switching to an explicitsetup() function, instead of using<script setup>.

Top-levelawait​

Top-levelawait can be used inside<script setup>. The resulting code will be compiled asasync setup():

<script setup>const post = await fetch(`/api/post/1`).then((r)=> r.json())</script>

In addition, the awaited expression will be automatically compiled in a format that preserves the current component instance context after theawait.

Import Statements​

Import statements in vue followECMAScript module specification. In addition, you can use aliases defined in your build tool configuration:

<script setup>import { ref }from 'vue'import { componentA }from './Components'import { componentB }from '@/Components'import { componentC }from '~/Components'</script>

Generics​

Generic type parameters can be declared using thegeneric attribute on the<script> tag:

<script setup lang="ts" generic="T">defineProps<{  items: T[]  selected: T}>()</script>

The value ofgeneric works exactly the same as the parameter list between<...> in TypeScript. For example, you can use multiple parameters,extends constraints, default types, and reference imported types:

<script  setup  lang="ts"  generic="T extends string | number,U extends Item">import type { Item }from './types'defineProps<{  id: T  list: U[]}>()</script>

You can use@vue-generic the directive to pass in explicit types, for when the type cannot be inferred:

<template>  <!-- @vue-generic {import('@/api').Actor} -->  <ApiSelect v-model="peopleIds" endpoint="/api/actors" id-prop="actorId" />  <!-- @vue-generic {import('@/api').Genre} -->  <ApiSelect v-model="genreIds" endpoint="/api/genres" id-prop="genreId" /></template>

In order to use a reference to a generic component in aref you need to use thevue-component-type-helpers library asInstanceType won't work.

<script  setup  lang="ts">import componentWithoutGenericsfrom '../component-without-generics.vue';import genericComponentfrom '../generic-component.vue';import type { ComponentExposed }from 'vue-component-type-helpers';// Works for a component without genericsref<InstanceType<typeof componentWithoutGenerics>>();ref<ComponentExposed<typeof genericComponent>>();

Restrictions​

• Due to the difference in module execution semantics, code inside<script setup> relies on the context of an SFC. When moved into external.js or.ts files, it may lead to confusion for both developers and tools. Therefore,<script setup> cannot be used with thesrc attribute.
• <script setup> does not support In-DOM Root Component Template.(Related Discussion)