@nuxt/docs 0.0.0 → 3.17.1

package/6.bridge/3.bridge-composition-api.md

@@ -0,0 +1,132 @@
+---
+title: Legacy Composition API
+description: 'Learn how to migrate to Composition API with Nuxt Bridge.'
+---
+
+Nuxt Bridge provides access to Composition API syntax. It is specifically designed to be aligned with Nuxt 3. Because of this, there are a few extra steps to take when enabling Nuxt Bridge, if you have been using the Composition API previously.
+
+## Remove Modules
+
+- Remove `@vue/composition-api` from your dependencies.
+- Remove `@nuxtjs/composition-api` from your dependencies (and from your modules in `nuxt.config`).
+
+## Using `@vue/composition-api`
+
+If you have been using just `@vue/composition-api` and not `@nuxtjs/composition-api`, then things are very straightforward.
+
+1. First, remove the plugin where you are manually registering the Composition API. Nuxt Bridge will handle this for you.
+
+   ```diff
+   - import Vue from 'vue'
+   - import VueCompositionApi from '@vue/composition-api'
+   -
+   - Vue.use(VueCompositionApi)
+   ```
+
+2. Otherwise, there is nothing you need to do. However, if you want, you can remove your explicit imports from `@vue/composition-api` and rely on Nuxt Bridge auto-importing them for you.
+
+## Migrating from `@nuxtjs/composition-api`
+
+Nuxt Bridge implements the Composition API slightly differently from `@nuxtjs/composition-api` and provides different composables (designed to be aligned with the composables that Nuxt 3 provides).
+
+Because some composables have been removed and don't yet have a replacement, this will be a slightly more complicated process.
+
+### Remove `@nuxtjs/composition-api/module` from your buildModules
+
+You don't have to immediately update your imports yet - Nuxt Bridge will automatically provide a 'shim' for most imports you currently have, to give you time to migrate to the new, Nuxt 3-compatible composables, with the following exceptions:
+
+- `withContext` has been removed. See [below](/docs/bridge/nuxt3-compatible-api#usecontext-and-withcontext).
+- `useStatic` has been removed. There is no current replacement. Feel free to raise a discussion if you have a use case for this.
+- `reqRef` and `reqSsrRef`, which were deprecated, have now been removed entirely. Follow the instructions below regarding [ssrRef](/docs/bridge/nuxt3-compatible-api#ssrref-and-shallowssrref) to replace this.
+
+### Set `bridge.capi`
+
+```ts
+import { defineNuxtConfig } from '@nuxt/bridge'
+
+export default defineNuxtConfig({
+  bridge: {
+    capi: true,
+    nitro: false // If migration to Nitro is complete, set to true
+  }
+})
+```
+
+For each other composable you are using from `@nuxtjs/composition-api`, follow the steps below.
+
+### useFetch
+
+`$fetchState` and `$fetch` have been removed.
+
+```diff
+const {
+- $fetch,
+- $fetchState,
++ fetch,
++ fetchState,
+} = useFetch(() => { posts.value = await $fetch('/api/posts') })
+```
+
+### `defineNuxtMiddleware`
+
+This was a type-helper stub function that is now removed.
+
+Remove the `defineNuxtMiddleware` wrapper:
+
+```diff
+- import { defineNuxtMiddleware } from '@nuxtjs/composition-api`
+- export default defineNuxtMiddleware((ctx) => {})
++ export default (ctx) => {}
+```
+
+For typescript support, you can use `@nuxt/types`:
+
+```ts
+import type { Middleware } from '@nuxt/types'
+
+export default <Middleware> function (ctx) { }
+```
+
+### `defineNuxtPlugin`
+
+This was a type-helper stub function that is now removed.
+
+You may also keep using Nuxt 2-style plugins, by removing the function (as with [defineNuxtMiddleware](#definenuxtmiddleware)).
+
+Remove the `defineNuxtPlugin` wrapper:
+
+```diff
+- import { defineNuxtPlugin } from '@nuxtjs/composition-api'
+- export default defineNuxtPlugin((ctx, inject) => {})
++ export default (ctx, inject) => {}
+```
+
+For typescript support, you can use `@nuxt/types`:
+
+```ts
+import type { Plugin } from '@nuxt/types'
+
+export default <Plugin> function (ctx, inject) {}
+```
+
+::warning
+While this example is valid, Nuxt 3 introduces a new defineNuxtPlugin function that has a slightly different signature.
+::
+
+:ReadMore{link="/docs/guide/directory-structure/plugins#creating-plugins"}
+
+### `useRouter` and `useRoute`
+
+Nuxt Bridge provides direct replacements for these composables via [`useRouter`](/docs/api/composables/use-router)  and `useRoute`.
+
+The only key difference is that [`useRoute`](/docs/api/composables/use-route) no longer returns a computed property.
+
+```diff
+- import { useRouter, useRoute } from '@nuxtjs/composition-api'
+
+  const router = useRouter()
+  const route = useRoute()
+
+- console.log(route.value.path)
++ console.log(route.path)
+```

package/6.bridge/4.plugins-and-middleware.md

@@ -0,0 +1,65 @@
+---
+title: Plugins and Middleware
+description: 'Learn how to migrate from Nuxt 2 to Nuxt Bridge new plugins and middleware.'
+---
+
+## New Plugins Format
+
+You can now migrate to the Nuxt 3 plugins API, which is slightly different in format from Nuxt 2.
+
+Plugins now take only one argument (`nuxtApp`). You can find out more in [the docs](/docs/guide/directory-structure/plugins).
+
+```js [plugins/hello.ts]
+export default defineNuxtPlugin(nuxtApp => {
+  nuxtApp.provide('injected', () => 'my injected function')
+  // now available on `nuxtApp.$injected`
+})
+```
+
+::note
+If you want to use the new Nuxt composables (such as [`useNuxtApp`](/docs/api/composables/use-nuxt-app) or `useRuntimeConfig`) within your plugins, you will need to use the `defineNuxtPlugin` helper for those plugins.
+::
+
+::warning
+Although a compatibility interface is provided via `nuxtApp.vueApp` you should avoid registering plugins, directives, mixins or components this way without adding your own logic to ensure they are not installed more than once, or this may cause a memory leak.
+::
+
+## New Middleware Format
+
+You can now migrate to the Nuxt 3 middleware API, which is slightly different in format from Nuxt 2.
+
+Middleware now take only two argument (`to`, `from`). You can find out more in [the docs](/docs/guide/directory-structure/middleware).
+
+```ts twoslash
+export default defineNuxtRouteMiddleware((to) => {
+  if (to.path !== '/') {
+    return navigateTo('/')
+  }
+})
+```
+
+::important
+Use of `defineNuxtRouteMiddleware` is not supported outside of the middleware directory.
+::
+
+## definePageMeta
+
+You can also use [`definePageMeta`](/docs/api/utils/define-page-meta) in Nuxt Bridge.
+
+You can be enabled with the `macros.pageMeta` option in your configuration file
+
+```ts [nuxt.config.ts]
+import { defineNuxtConfig } from '@nuxt/bridge'
+
+export default defineNuxtConfig({
+  bridge: {
+    macros: {
+      pageMeta: true
+    }
+  }
+})
+```
+
+::note
+But only for `middleware` and `layout`.
+::

package/6.bridge/5.nuxt3-compatible-api.md

@@ -0,0 +1,204 @@
+---
+title: New Composition API
+description: Nuxt Bridge implements composables compatible with Nuxt 3.
+---
+
+By migrating from `@nuxtjs/composition-api` to the Nuxt 3 compatible API, there will be less rewriting when migrating to Nuxt 3.
+
+## `ssrRef` and `shallowSsrRef`
+
+These two functions have been replaced with a new composable that works very similarly under the hood: `useState`.
+
+The key differences are that you must provide a _key_ for this state (which Nuxt generated automatically for `ssrRef` and `shallowSsrRef`), and that it can only be called within a Nuxt 3 plugin (which is defined by `defineNuxtPlugin`) or a component instance. (In other words, you cannot use [`useState`](/docs/api/composables/use-state) with a global/ambient context, because of the danger of shared state across requests.)
+
+```diff
+- import { ssrRef } from '@nuxtjs/composition-api'
+
+- const ref1 = ssrRef('initialData')
+- const ref2 = ssrRef(() => 'factory function')
++ const ref1 = useState('ref1-key', () => 'initialData')
++ const ref2 = useState('ref2-key', () => 'factory function')
+  // accessing the state
+  console.log(ref1.value)
+```
+
+Because the state is keyed, you can access the same state from multiple locations, as long as you are using the same key.
+
+You can read more about how to use this composable in [the Nuxt 3 docs](/docs/api/composables/use-state).
+
+## `ssrPromise`
+
+This function has been removed, and you will need to find an alternative implementation if you were using it. If you have a use case for `ssrPromise`, please let us know via a discussion.
+
+## `onGlobalSetup`
+
+This function has been removed, but its use cases can be met by using [`useNuxtApp`](/docs/api/composables/use-nuxt-app) or [`useState`](/docs/api/composables/use-state) within `defineNuxtPlugin`. You can also run any custom code within the `setup()` function of a layout.
+
+```diff
+- import { onGlobalSetup } from '@nuxtjs/composition-api'
+
+- export default () => {
+-   onGlobalSetup(() => {
++ export default defineNuxtPlugin((nuxtApp) => {
++   nuxtApp.hook('vue:setup', () => {
+      // ...
+    })
+- }
++ })
+```
+
+## `useStore`
+
+In order to access Vuex store instance, you can use `useNuxtApp().$store`.
+
+```diff
+- import { useStore } from '@nuxtjs/composition-api`
++ const { $store } = useNuxtApp()
+```
+
+## `useContext` and `withContext`
+
+You can access injected helpers using `useNuxtApp`.
+
+```diff
+- import { useContext } from '@nuxtjs/composition-api`
++ const { $axios } = useNuxtApp()
+```
+
+::note
+`useNuxtApp()` also provides a key called `nuxt2Context` which contains all the same properties you would normally access from Nuxt 2 context, but it's advised _not_ to use this directly, as it won't exist in Nuxt 3. Instead, see if there is another way to access what you need. (If not, please raise a feature request or discussion.)
+::
+
+## `wrapProperty`
+
+This helper function is not provided any more but you can replace it with the following code:
+
+```js
+const wrapProperty = (property, makeComputed = true) => () => {
+  const vm = getCurrentInstance().proxy
+  return makeComputed ? computed(() => vm[property]) : vm[property]
+}
+```
+
+## `useAsync` and `useFetch`
+
+These two composables can be replaced with `useLazyAsyncData` and `useLazyFetch`, which are documented [in the Nuxt 3 docs](/docs/getting-started/data-fetching). Just like the previous `@nuxtjs/composition-api` composables, these composables do not block route navigation on the client-side (hence the 'lazy' part of the name).
+
+::important
+Note that the API is entirely different, despite similar sounding names. Importantly, you should not attempt to change the value of other variables outside the composable (as you may have been doing with the previous `useFetch`).
+::
+
+::warning
+The `useLazyFetch` must have been configured for [Nitro](/docs/bridge/nitro).
+::
+
+Migrating to the new composables from `useAsync`:
+
+```diff
+<script setup>
+- import { useAsync } from '@nuxtjs/composition-api'
+- const posts = useAsync(() => $fetch('/api/posts'))
++ const { data: posts } = useLazyAsyncData('posts', () => $fetch('/api/posts'))
++ // or, more simply!
++ const { data: posts } = useLazyFetch('/api/posts')
+</script>
+```
+
+Migrating to the new composables from `useFetch`:
+
+```diff
+<script setup>
+- import { useFetch } from '@nuxtjs/composition-api'
+- const posts = ref([])
+- const { fetch } = useFetch(() => { posts.value = await $fetch('/api/posts') })
++ const { data: posts, refresh } = useLazyAsyncData('posts', () => $fetch('/api/posts'))
++ // or, more simply!
++ const { data: posts, refresh } = useLazyFetch('/api/posts')
+  function updatePosts() {
+-   return fetch()
++   return refresh()
+  }
+</script>
+```
+
+### `useMeta`
+
+In order to interact with `vue-meta`, you may use `useNuxt2Meta`, which will work in Nuxt Bridge (but not Nuxt 3) and will allow you to manipulate your meta tags in a `vue-meta`-compatible way.
+
+```diff
+<script setup>
+- import { useMeta } from '@nuxtjs/composition-api'
+  useNuxt2Meta({
+    title: 'My Nuxt App',
+  })
+</script>
+```
+
+You can also pass in computed values or refs, and the meta values will be updated reactively:
+
+```ts
+<script setup>
+const title = ref('my title')
+useNuxt2Meta({
+  title,
+})
+title.value = 'new title'
+</script>
+```
+
+::note
+Be careful not to use both `useNuxt2Meta()` and the Options API `head()` within the same component, as behavior may be unpredictable.
+::
+
+Nuxt Bridge also provides a Nuxt 3-compatible meta implementation that can be accessed with the [`useHead`](/docs/api/composables/use-head) composable.
+
+```diff
+<script setup>
+- import { useMeta } from '@nuxtjs/composition-api'
+  useHead({
+    title: 'My Nuxt App',
+  })
+</script>
+```
+
+You will also need to enable it explicitly in your `nuxt.config`:
+
+```js
+import { defineNuxtConfig } from '@nuxt/bridge'
+export default defineNuxtConfig({
+  bridge: {
+    meta: true
+  }
+})
+```
+
+This [`useHead`](/docs/api/composables/use-head) composable uses `@unhead/vue` under the hood (rather than `vue-meta`) to manipulate your `<head>`. Accordingly, it is recommended not to use both the native Nuxt 2 `head()` properties as well as [`useHead`](/docs/api/composables/use-head) , as they may conflict.
+
+For more information on how to use this composable, see [the Nuxt 3 docs](/docs/getting-started/seo-meta).
+
+### Explicit Imports
+
+Nuxt exposes every auto-import with the `#imports` alias that can be used to make the import explicit if needed:
+
+```vue
+<script setup lang="ts">
+import { ref, computed } from '#imports'
+
+const count = ref(1)
+const double = computed(() => count.value * 2)
+</script>
+```
+
+### Disabling Auto-imports
+
+If you want to disable auto-importing composables and utilities, you can set `imports.autoImport` to `false` in the `nuxt.config` file.
+
+```ts [nuxt.config.ts]
+export default defineNuxtConfig({
+  imports: {
+    autoImport: false
+  }
+})
+```
+
+This will disable auto-imports completely but it's still possible to use [explicit imports](#explicit-imports) from `#imports`.

package/6.bridge/6.meta.md

@@ -0,0 +1,117 @@
+---
+title: Meta Tags
+description: 'Learn how to migrate from Nuxt 2 to Nuxt Bridge new meta tags.'
+---
+
+If you need to access the component state with `head`, you should migrate to using [`useHead`](/docs/api/composables/use-head) .
+
+If you need to use the Options API, there is a `head()` method you can use when you use `defineNuxtComponent`.
+
+## Migration
+
+### Set `bridge.meta`
+
+```js
+import { defineNuxtConfig } from '@nuxt/bridge'
+export default defineNuxtConfig({
+  bridge: {
+    meta: true,
+    nitro: false // If migration to Nitro is complete, set to true
+  }
+})
+```
+
+### Update head properties
+
+In your `nuxt.config`, rename `head` to `meta`. (Note that objects no longer have a `hid` key for deduplication.)
+
+::code-group
+
+```ts [Nuxt 2]
+export default {
+  head: {
+    titleTemplate: '%s - Nuxt',
+    meta: [
+      { charset: 'utf-8' },
+      { name: 'viewport', content: 'width=device-width, initial-scale=1' },
+      { hid: 'description', name: 'description', content: 'Meta description' }
+    ]
+  }
+}
+```
+
+```ts [Nuxt 3]
+export default defineNuxtConfig({
+  app: {
+    head: {
+      titleTemplate: '%s - Nuxt',
+      meta: [
+        { charset: 'utf-8' },
+        { name: 'viewport', content: 'width=device-width, initial-scale=1' },
+        { name: 'description', content: 'Meta description' }
+      ]
+    }
+  }
+})
+```
+
+::
+
+## `useHead` Composables
+
+Nuxt Bridge provides a new Nuxt 3 meta API that can be accessed with a new [`useHead`](/docs/api/composables/use-head) composable.
+
+```vue
+<script setup lang="ts">
+useHead({
+  title: 'My Nuxt App',
+})
+</script>
+```
+
+::tip
+This [`useHead`](/docs/api/composables/use-head) composable uses `@unhead/vue` under the hood (rather than `vue-meta`) to manipulate your `<head>`.
+::
+
+::warning
+We recommend not using the native Nuxt 2 `head()` properties in addition to [`useHead`](/docs/api/composables/use-head) , as they may conflict.
+::
+
+For more information on how to use this composable, see [the docs](/docs/getting-started/seo-meta).
+
+## Options API
+
+```vue
+<script>
+// if using options API `head` method you must use `defineNuxtComponent`
+export default defineNuxtComponent({
+  head (nuxtApp) {
+    // `head` receives the nuxt app but cannot access the component instance
+    return {
+      meta: [{
+        name: 'description',
+        content: 'This is my page description.'
+      }]
+    }
+  }
+})
+</script>
+```
+
+::warning
+Possible breaking change: `head` receives the nuxt app but cannot access the component instance. If the code in your `head` tries to access the data object through `this` or `this.$data`, you will need to migrate to the `useHead` composable.
+::
+
+## Title Template
+
+If you want to use a function (for full control), then this cannot be set in your nuxt.config, and it is recommended instead to set it within your `/layouts` directory.
+
+```vue [layouts/default.vue]
+<script setup lang="ts">
+useHead({
+  titleTemplate: (titleChunk) => {
+    return titleChunk ? `${titleChunk} - Site Title` : 'Site Title';
+  }
+})
+</script>
+```

package/6.bridge/7.runtime-config.md

@@ -0,0 +1,38 @@
+---
+title: Runtime Config
+description: 'Nuxt provides a runtime config API to expose configuration and secrets within your application.'
+---
+
+::warning
+When using `runtimeConfig` option, [nitro](/docs/bridge/nitro) must have been configured.
+::
+
+## Update Runtime Config
+
+Nuxt 3 approaches runtime config differently than Nuxt 2, using a new combined `runtimeConfig` option.
+
+First, you'll need to combine your `publicRuntimeConfig` and `privateRuntimeConfig` properties into a new one called `runtimeConfig`, with the public config within a key called `public`.
+
+```diff
+// nuxt.config.js
+- privateRuntimeConfig: {
+-   apiKey: process.env.NUXT_API_KEY || 'super-secret-key'
+- },
+- publicRuntimeConfig: {
+-   websiteURL: 'https://public-data.com'
+- }
++ runtimeConfig: {
++   apiKey: process.env.NUXT_API_KEY || 'super-secret-key',
++   public: {
++     websiteURL: 'https://public-data.com'
++   }
++ }
+```
+
+This also means that when you need to access public runtime config, it's behind a property called `public`. If you use public runtime config, you'll need to update your code.
+
+```diff
+// MyWidget.vue
+- <div>Website: {{ $config.websiteURL }}</div>
++ <div>Website: {{ $config.public.websiteURL }}</div>
+```

package/6.bridge/8.nitro.md

@@ -0,0 +1,102 @@
+---
+title: Nitro
+description: 'Activate Nitro to your Nuxt 2 application with Nuxt Bridge.'
+---
+
+## Remove Modules
+
+- Remove `@nuxt/nitro`: Bridge injects same functionality
+
+## Update Config
+
+```ts [nuxt.config.ts]
+import { defineNuxtConfig } from '@nuxt/bridge'
+
+export default defineNuxtConfig({
+  bridge: {
+    nitro: true
+  }
+})
+```
+
+## Update Your Scripts
+
+You will also need to update your scripts within your `package.json` to reflect the fact that Nuxt will now produce a Nitro server as build output.
+
+### Install Nuxi
+
+Install `nuxi` as a development dependency:
+
+::code-group{sync="pm"}
+
+```bash [npm]
+npm install -D nuxi
+```
+
+```bash [yarn]
+yarn add --dev nuxi
+```
+
+```bash [pnpm]
+pnpm add -D nuxi
+```
+
+```bash [bun]
+bun add -D nuxi
+```
+
+::
+
+### Nuxi
+
+Nuxt 3 introduced the new Nuxt CLI command [`nuxi`](/docs/api/commands/add). Update your scripts as follows to leverage the better support from Nuxt Bridge:
+
+```diff
+{
+  "scripts": {
+-   "dev": "nuxt",
++   "dev": "nuxi dev",
+-   "build": "nuxt build",
++   "build": "nuxi build",
+-   "start": "nuxt start",
++   "start": "nuxi preview"
+  }
+}
+```
+
+::tip
+If `nitro: false`, use the `nuxt2` command.
+::
+
+### Static Target
+
+If you have set `target: 'static'` in your `nuxt.config` then you need to ensure that you update your build script to be `nuxi generate`.
+
+```json [package.json]
+{
+  "scripts": {
+    "build": "nuxi generate"
+  }
+}
+```
+
+### Server Target
+
+For all other situations, you can use the `nuxi build` command.
+
+```json [package.json]
+{
+  "scripts": {
+    "build": "nuxi build",
+    "start": "nuxi preview"
+  }
+}
+```
+
+## Exclude Built Nitro Folder From Git
+
+Add the folder `.output` to the `.gitignore` file.
+
+## Ensure Everything Goes Well
+
+✔️ Try with `nuxi dev` and `nuxi build` (or `nuxi generate`) to see if everything goes well.

package/6.bridge/9.vite.md

@@ -0,0 +1,37 @@
+---
+title: Vite
+description: 'Activate Vite to your Nuxt 2 application with Nuxt Bridge.'
+---
+
+::warning
+When using `vite`, [nitro](/docs/bridge/nitro) must have been configured.
+::
+
+## Remove Modules
+
+- Remove `nuxt-vite`: Bridge enables same functionality
+
+## Update Config
+
+```ts [nuxt.config.ts]
+import { defineNuxtConfig } from '@nuxt/bridge'
+
+export default defineNuxtConfig({
+  bridge: {
+    vite: true,
+    nitro: true
+  }
+})
+```
+
+## Configuration
+
+```ts [nuxt.config.ts]
+import { defineNuxtConfig } from '@nuxt/bridge'
+
+export default defineNuxtConfig({
+  vite: {
+    // Config for Vite
+  }
+})
+```

package/7.migration/.navigation.yml

@@ -0,0 +1,3 @@
+title: 'Migrate to Nuxt 3'
+titleTemplate: 'Migrate to Nuxt 3: %s'
+icon: i-lucide-circle-arrow-up