From 9d09b2d3652605d5a0b6e2a8bef1390ab957ea5d Mon Sep 17 00:00:00 2001
From: wattanx <wattan.dev@gmail.com>
Date: Tue, 2 Jul 2024 22:31:30 +0900
Subject: [PATCH 1/7] feat: add experimental schema

---
 .../bridge-schema/src/config/experimental.ts  | 38 +++++++++++++++++++
 packages/bridge-schema/src/config/index.ts    |  2 +
 2 files changed, 40 insertions(+)
 create mode 100644 packages/bridge-schema/src/config/experimental.ts

diff --git a/packages/bridge-schema/src/config/experimental.ts b/packages/bridge-schema/src/config/experimental.ts
new file mode 100644
index 00000000..a9522ebd
--- /dev/null
+++ b/packages/bridge-schema/src/config/experimental.ts
@@ -0,0 +1,38 @@
+import { defineUntypedSchema } from 'untyped'
+
+export default defineUntypedSchema({
+  /**
+   * `future` is for early opting-in to new features that will become default in a future
+   * (possibly major) version of the framework.
+   */
+  future: {
+    /**
+     * Enable early access to future features or flags.
+     *
+     * It is currently not configurable but may be in future.
+     * @type {4}
+     */
+    compatibilityVersion: 4,
+  },
+  experimental: {
+    defaults: {
+      /**
+       * Options that apply to `useAsyncData` (and also therefore `useFetch`)
+       */
+      useAsyncData: {
+        /** @type {'undefined' | 'null'} */
+        value: {
+          async $resolve (val, get) {
+            return val ?? ((await get('future') as Record<string, unknown>).compatibilityVersion === 4 ? 'undefined' : 'null')
+          },
+        },
+        /** @type {'undefined' | 'null'} */
+        errorValue: {
+          async $resolve (val, get) {
+            return val ?? ((await get('future') as Record<string, unknown>).compatibilityVersion === 4 ? 'undefined' : 'null')
+          },
+        },
+      },
+    }
+  }
+})
\ No newline at end of file
diff --git a/packages/bridge-schema/src/config/index.ts b/packages/bridge-schema/src/config/index.ts
index c32bf907..20164bfb 100644
--- a/packages/bridge-schema/src/config/index.ts
+++ b/packages/bridge-schema/src/config/index.ts
@@ -2,6 +2,7 @@ import app from './app'
 import build from './build'
 import cli from './cli'
 import common from './common'
+import experimental from './experimental'
 import generate from './generate'
 import messages from './messages'
 import render from './render'
@@ -31,6 +32,7 @@ export default {
   ...build,
   ...cli,
   ...common,
+  ...experimental,
   ...generate,
   ...messages,
   ...render,

From df4d36675cd025d91ef03b5752dc483376ab6ad1 Mon Sep 17 00:00:00 2001
From: wattanx <wattan.dev@gmail.com>
Date: Tue, 2 Jul 2024 22:41:36 +0900
Subject: [PATCH 2/7] fix: fix type error

---
 packages/bridge/src/global-middleware-template.ts | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/packages/bridge/src/global-middleware-template.ts b/packages/bridge/src/global-middleware-template.ts
index a48e06cb..2ae0acfa 100644
--- a/packages/bridge/src/global-middleware-template.ts
+++ b/packages/bridge/src/global-middleware-template.ts
@@ -1,17 +1,12 @@
 
-import type { Nuxt, NuxtApp } from '@nuxt/schema'
+import type { NuxtTemplate } from '@nuxt/schema'
 import { genArrayFromRaw, genImport, genSafeVariableName } from 'knitwork'
 import { resolveFiles } from '@nuxt/kit'
 import { getNameFromPath, hasSuffix } from './utils/names'
 
-interface TemplateContext {
-  nuxt: Nuxt
-  app: NuxtApp & { templateVars: Record<string, any> }
-}
-
-export const globalMiddlewareTemplate = {
+export const globalMiddlewareTemplate: NuxtTemplate = {
   filename: 'global-middleware.mjs',
-  getContents: async ({ nuxt, app }: TemplateContext) => {
+  getContents: async ({ nuxt, app }) => {
     app.middleware = []
     const middlewareDir = nuxt.options.dir.middleware || 'middleware'
     const middlewareFiles = await resolveFiles(nuxt.options.srcDir, `${middlewareDir}/*{${nuxt.options.extensions.join(',')}}`)

From cf06a2860e4f2a23722ab9bfe2105ba14c1611ab Mon Sep 17 00:00:00 2001
From: wattanx <wattan.dev@gmail.com>
Date: Tue, 2 Jul 2024 23:52:54 +0900
Subject: [PATCH 3/7] feat: add virtual file

---
 packages/bridge/module.cjs |  3 +++
 packages/bridge/src/app.ts | 17 +++++++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/packages/bridge/module.cjs b/packages/bridge/module.cjs
index 29a9a429..8d9be4b8 100644
--- a/packages/bridge/module.cjs
+++ b/packages/bridge/module.cjs
@@ -19,6 +19,9 @@ module.exports.defineNuxtConfig = (config = {}) => {
   // Initialize nitro options
   config.nitro = config.nitro || {}
 
+  config.future = config.future || {}
+  config.experimental = config.experimental || {}
+
   // Nuxt kit depends on this flag to check bridge compatibility
   config.bridge = typeof config.bridge === 'object' ? config.bridge : {}
   config.bridge._version = pkg.version
diff --git a/packages/bridge/src/app.ts b/packages/bridge/src/app.ts
index e6ab9e48..8b3588a8 100644
--- a/packages/bridge/src/app.ts
+++ b/packages/bridge/src/app.ts
@@ -2,6 +2,8 @@ import { useNuxt, addTemplate, resolveAlias, addWebpackPlugin, addVitePlugin, ad
 import { NuxtModule } from '@nuxt/schema'
 import { normalize, resolve } from 'pathe'
 import { resolveImports } from 'mlly'
+import { applyDefaults } from 'untyped'
+import { NuxtConfigSchema } from '@nuxt/bridge-schema'
 import { componentsTypeTemplate, schemaTemplate, middlewareTypeTemplate } from './type-templates'
 import { distDir } from './dirs'
 import { VueCompat } from './vue-compat'
@@ -105,6 +107,21 @@ export async function setupAppBridge (_options: any) {
 
   addTemplate(globalMiddlewareTemplate)
 
+  
+  if (nuxt.options.future?.compatibilityVersion === 4) {
+    // @ts-expect-error only partially supported by nuxt bridge
+    nuxt.options.experimental = (await applyDefaults({ future: NuxtConfigSchema['future'], experimental: NuxtConfigSchema['experimental'] }, nuxt.options.experimental)).experimental
+
+    addTemplate({
+      filename: 'nuxt.config.mjs',
+      getContents: (ctx) => {
+        return [
+          `export const asyncDataDefaults = ${JSON.stringify(ctx.nuxt.options.experimental.defaults.useAsyncData)}`,
+        ].join('\n\n')
+      }
+    })
+  }
+
   // Alias vue3 utilities to vue2
   const { dst: vueCompat } = addTemplate({ src: resolve(distDir, 'runtime/vue2-bridge.mjs') })
   addWebpackPlugin(VueCompat.webpack({ src: vueCompat }))

From 02d4dd0752c90a3afd892fd35a0acc477f935864 Mon Sep 17 00:00:00 2001
From: wattanx <wattan.dev@gmail.com>
Date: Sat, 6 Jul 2024 23:39:12 +0900
Subject: [PATCH 4/7] fix: use undefined rather than null for data fetching
 defaults

---
 .../bridge-schema/src/config/experimental.ts  | 14 ++---
 packages/bridge/src/app.ts                    | 41 ++++++++-----
 .../src/runtime/composables/asyncData.ts      | 60 +++++++++++--------
 .../bridge/src/runtime/composables/error.ts   |  4 +-
 packages/bridge/src/runtime/defaults.js       |  2 +
 packages/bridge/src/type-templates.ts         | 16 ++++-
 packages/bridge/types.d.ts                    |  6 ++
 playground/pages/async-data.vue               |  8 +++
 test/bridge.test.ts                           | 10 ++++
 9 files changed, 111 insertions(+), 50 deletions(-)
 create mode 100644 packages/bridge/src/runtime/defaults.js

diff --git a/packages/bridge-schema/src/config/experimental.ts b/packages/bridge-schema/src/config/experimental.ts
index a9522ebd..762ebd1e 100644
--- a/packages/bridge-schema/src/config/experimental.ts
+++ b/packages/bridge-schema/src/config/experimental.ts
@@ -10,9 +10,9 @@ export default defineUntypedSchema({
      * Enable early access to future features or flags.
      *
      * It is currently not configurable but may be in future.
-     * @type {4}
+     * @type {3 | 4}
      */
-    compatibilityVersion: 4,
+    compatibilityVersion: 3
   },
   experimental: {
     defaults: {
@@ -24,15 +24,15 @@ export default defineUntypedSchema({
         value: {
           async $resolve (val, get) {
             return val ?? ((await get('future') as Record<string, unknown>).compatibilityVersion === 4 ? 'undefined' : 'null')
-          },
+          }
         },
         /** @type {'undefined' | 'null'} */
         errorValue: {
           async $resolve (val, get) {
             return val ?? ((await get('future') as Record<string, unknown>).compatibilityVersion === 4 ? 'undefined' : 'null')
-          },
-        },
-      },
+          }
+        }
+      }
     }
   }
-})
\ No newline at end of file
+})
diff --git a/packages/bridge/src/app.ts b/packages/bridge/src/app.ts
index 8b3588a8..bc83618c 100644
--- a/packages/bridge/src/app.ts
+++ b/packages/bridge/src/app.ts
@@ -4,7 +4,7 @@ import { normalize, resolve } from 'pathe'
 import { resolveImports } from 'mlly'
 import { applyDefaults } from 'untyped'
 import { NuxtConfigSchema } from '@nuxt/bridge-schema'
-import { componentsTypeTemplate, schemaTemplate, middlewareTypeTemplate } from './type-templates'
+import { componentsTypeTemplate, schemaTemplate, middlewareTypeTemplate, appDefaults } from './type-templates'
 import { distDir } from './dirs'
 import { VueCompat } from './vue-compat'
 import { globalMiddlewareTemplate } from './global-middleware-template'
@@ -69,6 +69,7 @@ export async function setupAppBridge (_options: any) {
   nuxt.hook('prepare:types', ({ references }) => {
     references.push({ path: resolve(nuxt.options.buildDir, 'types/components.d.ts') })
     references.push({ path: resolve(nuxt.options.buildDir, 'types/middleware.d.ts') })
+    references.push({ path: resolve(nuxt.options.buildDir, 'types/app-defaults.d.ts') })
   })
 
   // Augment schema with module types
@@ -107,20 +108,30 @@ export async function setupAppBridge (_options: any) {
 
   addTemplate(globalMiddlewareTemplate)
 
-  
-  if (nuxt.options.future?.compatibilityVersion === 4) {
-    // @ts-expect-error only partially supported by nuxt bridge
-    nuxt.options.experimental = (await applyDefaults({ future: NuxtConfigSchema['future'], experimental: NuxtConfigSchema['experimental'] }, nuxt.options.experimental)).experimental
-
-    addTemplate({
-      filename: 'nuxt.config.mjs',
-      getContents: (ctx) => {
-        return [
-          `export const asyncDataDefaults = ${JSON.stringify(ctx.nuxt.options.experimental.defaults.useAsyncData)}`,
-        ].join('\n\n')
-      }
-    })
-  }
+  // @ts-expect-error only partially supported by nuxt bridge
+  nuxt.options.experimental = (
+    await applyDefaults(
+      { future: NuxtConfigSchema.future, experimental: NuxtConfigSchema.experimental },
+      { future: nuxt.options.future, experimental: nuxt.options.experimental }
+    )
+  ).experimental;
+
+  addTemplate({
+    filename: 'nuxt.config.mjs',
+    getContents: (ctx) => {
+      return [
+        `export const asyncDataDefaults = ${JSON.stringify({
+          ...ctx.nuxt.options.experimental.defaults.useAsyncData,
+          value: ctx.nuxt.options.experimental.defaults.useAsyncData.value === 'null' ? null : undefined,
+          errorValue: ctx.nuxt.options.experimental.defaults.useAsyncData.errorValue === 'null' ? null : undefined
+        })}`,
+        `export const resetAsyncDataToUndefined = ${ctx.nuxt.options.experimental.resetAsyncDataToUndefined}`,
+        `export const nuxtDefaultErrorValue = ${ctx.nuxt.options.future.compatibilityVersion === 4 ? 'undefined' : 'null'}`
+      ].join('\n\n')
+    }
+  })
+
+  addTemplate(appDefaults)
 
   // Alias vue3 utilities to vue2
   const { dst: vueCompat } = addTemplate({ src: resolve(distDir, 'runtime/vue2-bridge.mjs') })
diff --git a/packages/bridge/src/runtime/composables/asyncData.ts b/packages/bridge/src/runtime/composables/asyncData.ts
index 8d7f7a43..2f33cb17 100644
--- a/packages/bridge/src/runtime/composables/asyncData.ts
+++ b/packages/bridge/src/runtime/composables/asyncData.ts
@@ -5,6 +5,13 @@ import { useNuxtApp } from '../nuxt'
 import { toArray } from '../utils/toArray'
 import { createError } from './error'
 
+// @ts-expect-error virtual file
+import { asyncDataDefaults, resetAsyncDataToUndefined } from '#build/nuxt.config.mjs'
+
+// TODO: temporary module for backwards compatibility
+// @ts-expect-error virtual file
+import type { DefaultAsyncDataErrorValue, DefaultAsyncDataValue } from '#app/defaults'
+
 export type _Transform<Input = any, Output = any> = (input: Input) => Output | Promise<Output>
 
 export type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? Pick<T, K[number]> : T
@@ -19,7 +26,7 @@ export interface AsyncDataOptions<
   ResT,
   DataT = ResT,
   PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
-  DefaultT = null,
+  DefaultT = DefaultAsyncDataValue,
 > {
   /**
    * Whether to fetch on the server side.
@@ -92,7 +99,7 @@ export interface _AsyncData<DataT, ErrorT> {
   refresh: (opts?: AsyncDataExecuteOptions) => Promise<DataT>
   execute: (opts?: AsyncDataExecuteOptions) => Promise<DataT>
   clear: () => void
-  error: Ref<ErrorT | null>
+  error: Ref<ErrorT | DefaultAsyncDataErrorValue>
   status: Ref<AsyncDataRequestStatus>
 }
 
@@ -106,11 +113,11 @@ export function useAsyncData<
   DataE = Error,
   DataT = ResT,
   PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
-  DefaultT = null,
+  DefaultT = DefaultAsyncDataValue,
 > (
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 export function useAsyncData<
   ResT,
   DataE = Error,
@@ -120,18 +127,18 @@ export function useAsyncData<
 > (
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 export function useAsyncData<
   ResT,
   DataE = Error,
   DataT = ResT,
   PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
-  DefaultT = null,
+  DefaultT = DefaultAsyncDataValue,
 > (
   key: string,
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 export function useAsyncData<
   ResT,
   DataE = Error,
@@ -142,14 +149,14 @@ export function useAsyncData<
   key: string,
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 export function useAsyncData<
   ResT,
   DataE = Error,
   DataT = ResT,
   PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
-  DefaultT = null,
-> (...args: any[]): AsyncData<PickFrom<DataT, PickKeys>, DataE | null> {
+  DefaultT = DefaultAsyncDataValue,
+> (...args: any[]): AsyncData<PickFrom<DataT, PickKeys>, DataE | DefaultAsyncDataErrorValue> {
   const autoKey = typeof args[args.length - 1] === 'string' ? args.pop() : undefined
   if (typeof args[0] !== 'string') { args.unshift(autoKey) }
 
@@ -168,7 +175,7 @@ export function useAsyncData<
   const nuxt = useNuxtApp()
 
   // Used to get default values
-  const getDefault = () => null
+  const getDefault = () => asyncDataDefaults.value
   const getDefaultCachedData = () => nuxt.isHydrating ? nuxt.payload.data[key] : nuxt.static.data[key]
 
   // Apply defaults
@@ -189,7 +196,7 @@ export function useAsyncData<
 
   // Create or use a shared asyncData entity
   if (!nuxt._asyncData[key] || !options.immediate) {
-    nuxt.payload._errors[key] = nuxt.payload._errors[key] ?? null
+    nuxt.payload._errors[key] = nuxt.payload._errors[key] ?? asyncDataDefaults.errorValue
 
     const _ref = options.deep ? ref : shallowRef
 
@@ -197,7 +204,8 @@ export function useAsyncData<
       data: _ref(options.getCachedData!(key, nuxt) ?? options.default!()),
       pending: ref(!hasCachedData()),
       error: toRef(nuxt.payload._errors, key),
-      status: ref('idle')
+      status: ref('idle'),
+      _default: options.default!,
     }
   }
 
@@ -242,7 +250,7 @@ export function useAsyncData<
         nuxt.payload.data[key] = result
 
         asyncData.data.value = result
-        asyncData.error.value = null
+        asyncData.error.value = asyncDataDefaults.errorValue
         asyncData.status.value = 'success'
       })
       .catch((error: any) => {
@@ -336,11 +344,11 @@ export function useLazyAsyncData<
   DataE = Error,
   DataT = ResT,
   PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
-  DefaultT = null,
+  DefaultT = DefaultAsyncDataValue,
 > (
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 export function useLazyAsyncData<
   ResT,
   DataE = Error,
@@ -350,18 +358,18 @@ export function useLazyAsyncData<
 > (
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 export function useLazyAsyncData<
   ResT,
   DataE = Error,
   DataT = ResT,
   PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
-  DefaultT = null,
+  DefaultT = DefaultAsyncDataValue,
 > (
   key: string,
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 export function useLazyAsyncData<
   ResT,
   DataE = Error,
@@ -372,15 +380,15 @@ export function useLazyAsyncData<
   key: string,
   handler: (ctx?: NuxtAppCompat) => Promise<ResT>,
   options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>
-): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null>
+): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue>
 
 export function useLazyAsyncData<
   ResT,
   DataE = Error,
   DataT = ResT,
   PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
-  DefaultT = null,
-> (...args: any[]): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | null> {
+  DefaultT = DefaultAsyncDataValue,
+> (...args: any[]): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, DataE | DefaultAsyncDataErrorValue> {
   const autoKey = typeof args[args.length - 1] === 'string' ? args.pop() : undefined
   if (typeof args[0] !== 'string') { args.unshift(autoKey) }
   const [key, handler, options] = args as [string, (ctx?: NuxtAppCompat) => Promise<ResT>, AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>]
@@ -412,16 +420,16 @@ export function clearNuxtData (keys?: string | string[] | ((key: string) => bool
 
 function clearNuxtDataByKey (nuxtApp: NuxtAppCompat, key: string): void {
   if (key in nuxtApp.payload.data) {
-    nuxtApp.payload.data[key] = undefined
+    nuxtApp.payload.data[key] = asyncDataDefaults.value
   }
 
   if (key in nuxtApp.payload._errors) {
-    nuxtApp.payload._errors[key] = null
+    nuxtApp.payload._errors[key] = asyncDataDefaults.errorValue
   }
 
   if (nuxtApp._asyncData[key]) {
-    nuxtApp._asyncData[key]!.data.value = undefined
-    nuxtApp._asyncData[key]!.error.value = null
+    nuxtApp._asyncData[key]!.data.value = nuxtApp._asyncData[key]!.data.value = resetAsyncDataToUndefined ? undefined : nuxtApp._asyncData[key]!._default()
+    nuxtApp._asyncData[key]!.error.value = asyncDataDefaults.errorValue
     nuxtApp._asyncData[key]!.pending.value = false
     nuxtApp._asyncData[key]!.status.value = 'idle'
   }
diff --git a/packages/bridge/src/runtime/composables/error.ts b/packages/bridge/src/runtime/composables/error.ts
index 1e8a3d9d..d412c74d 100644
--- a/packages/bridge/src/runtime/composables/error.ts
+++ b/packages/bridge/src/runtime/composables/error.ts
@@ -1,6 +1,8 @@
 import { createError as _createError, H3Error } from 'h3'
 import { toRef } from 'vue'
 import { useNuxtApp } from '../nuxt'
+// @ts-expect-error virtual file
+import { nuxtDefaultErrorValue } from '#build/nuxt.config.mjs'
 
 export const useError = () => toRef(useNuxtApp().payload, 'error')
 
@@ -36,7 +38,7 @@ export const clearError = async (options: { redirect?: string } = {}) => {
   if (options.redirect) {
     await nuxtApp.$router.replace(options.redirect)
   }
-  error.value = null
+  error.value = nuxtDefaultErrorValue
 }
 
 export const isNuxtError = (err?: string | object): err is NuxtError => !!(err && typeof err === 'object' && ('__nuxt_error' in err))
diff --git a/packages/bridge/src/runtime/defaults.js b/packages/bridge/src/runtime/defaults.js
new file mode 100644
index 00000000..8a0e47a1
--- /dev/null
+++ b/packages/bridge/src/runtime/defaults.js
@@ -0,0 +1,2 @@
+// TODO: temporary module for backwards compatibility
+export {}
diff --git a/packages/bridge/src/type-templates.ts b/packages/bridge/src/type-templates.ts
index fe101636..2819651e 100644
--- a/packages/bridge/src/type-templates.ts
+++ b/packages/bridge/src/type-templates.ts
@@ -1,5 +1,5 @@
 import { isAbsolute, relative, join, resolve } from 'pathe'
-import type { Component, Nuxt, NuxtApp, NuxtTemplate } from '@nuxt/schema'
+import type { Component, Nuxt, NuxtApp, NuxtTemplate, NuxtTypeTemplate } from '@nuxt/schema'
 import { genDynamicImport, genString } from 'knitwork'
 import { defu } from 'defu'
 
@@ -150,3 +150,17 @@ export const schemaTemplate: NuxtTemplate<TemplateContext> = {
     ].join('\n')
   }
 }
+
+export const appDefaults: NuxtTypeTemplate = {
+  filename: 'types/app-defaults.d.ts',
+  getContents: (ctx) => {
+    const isV4 = ctx.nuxt.options.future.compatibilityVersion === 4
+    return `
+declare module '#app/defaults' {
+  type DefaultAsyncDataErrorValue = ${isV4 ? 'undefined' : 'null'}
+  type DefaultAsyncDataValue = ${isV4 ? 'undefined' : 'null'}
+  type DefaultErrorValue = ${isV4 ? 'undefined' : 'null'}
+  type DedupeOption = ${isV4 ? '\'cancel\' | \'defer\'' : 'boolean | \'cancel\' | \'defer\''}
+}`
+  }
+}
diff --git a/packages/bridge/types.d.ts b/packages/bridge/types.d.ts
index a47e798b..d87a4c28 100644
--- a/packages/bridge/types.d.ts
+++ b/packages/bridge/types.d.ts
@@ -80,4 +80,10 @@ declare module 'nitropack' {
   }
 }
 
+declare module '#app/defaults' {
+  type DefaultAsyncDataErrorValue = undefined
+  type DefaultAsyncDataValue = undefined
+  type DefaultErrorValue = undefined
+}
+
 export declare function defineNuxtConfig (config: NuxtConfig): NuxtConfig
diff --git a/playground/pages/async-data.vue b/playground/pages/async-data.vue
index 05bf4536..c2333756 100644
--- a/playground/pages/async-data.vue
+++ b/playground/pages/async-data.vue
@@ -28,6 +28,13 @@ const { data: clearableData2, clear } = useLazyAsyncData('clearableData-2', asyn
   }
 })
 
+const { data: immediateFalseData } = useLazyAsyncData('immediateFalse', async () => {
+  const text = await $fetch('/api/hello')
+  return {
+    text
+  }
+}, { immediate: false })
+
 if (process.server) {
   clearNuxtData('clearableData-1')
   clear()
@@ -43,6 +50,7 @@ if (process.server) {
 <template>
   <div>
     <div>data1: {{ data1 }}</div>
+    <div id="immediate-data">{{ immediateFalseData === null ? "null" : (immediateFalseData === undefined ? 'undefined' : immediateFalseData) }}</div>
     <div>error1: {{ error1 }}</div>
     <div>error2: {{ error2 }}</div>
     <div>error3: {{ error3 }}</div>
diff --git a/test/bridge.test.ts b/test/bridge.test.ts
index 29ad94b6..29368878 100644
--- a/test/bridge.test.ts
+++ b/test/bridge.test.ts
@@ -7,6 +7,7 @@ import { expectNoClientErrors, parseData, renderPage } from './utils'
 const isWebpack = process.env.TEST_BUILDER === 'webpack'
 const isNoResolve = process.env.TEST_RESOLVE === 'no-resolve'
 const isDev = process.env.TEST_ENV === 'dev'
+const isV4 = process.env.TEST_V4 === 'true'
 
 await setup({
   rootDir: fileURLToPath(new URL('../playground', import.meta.url)),
@@ -73,6 +74,15 @@ describe('nuxt composables', () => {
     expect(html).not.toContain('clearableData-1: clearableData')
     expect(html).not.toContain('clearableData-2: clearableData')
   })
+
+  it('should render default value', async () => {
+    const defaultValue = isV4 ? 'undefined' : 'null'
+
+    const { page } = await renderPage('/async-data');
+    expect(await page.locator('#immediate-data').getByText(defaultValue).textContent()).toBe(defaultValue)
+
+    await page.close()
+  })
 })
 
 describe('head tags', () => {

From 11404bda586ebf2a5209198ab5a04b82cfadbb6b Mon Sep 17 00:00:00 2001
From: wattanx <wattan.dev@gmail.com>
Date: Sat, 6 Jul 2024 23:44:51 +0900
Subject: [PATCH 5/7] fix: fix lint

---
 packages/bridge/src/app.ts                           | 2 +-
 packages/bridge/src/runtime/composables/asyncData.ts | 2 +-
 playground/pages/async-data.vue                      | 3 +++
 test/bridge.test.ts                                  | 2 +-
 4 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/packages/bridge/src/app.ts b/packages/bridge/src/app.ts
index bc83618c..38bd787e 100644
--- a/packages/bridge/src/app.ts
+++ b/packages/bridge/src/app.ts
@@ -114,7 +114,7 @@ export async function setupAppBridge (_options: any) {
       { future: NuxtConfigSchema.future, experimental: NuxtConfigSchema.experimental },
       { future: nuxt.options.future, experimental: nuxt.options.experimental }
     )
-  ).experimental;
+  ).experimental
 
   addTemplate({
     filename: 'nuxt.config.mjs',
diff --git a/packages/bridge/src/runtime/composables/asyncData.ts b/packages/bridge/src/runtime/composables/asyncData.ts
index 2f33cb17..54a38d95 100644
--- a/packages/bridge/src/runtime/composables/asyncData.ts
+++ b/packages/bridge/src/runtime/composables/asyncData.ts
@@ -205,7 +205,7 @@ export function useAsyncData<
       pending: ref(!hasCachedData()),
       error: toRef(nuxt.payload._errors, key),
       status: ref('idle'),
-      _default: options.default!,
+      _default: options.default!
     }
   }
 
diff --git a/playground/pages/async-data.vue b/playground/pages/async-data.vue
index c2333756..cf1192ab 100644
--- a/playground/pages/async-data.vue
+++ b/playground/pages/async-data.vue
@@ -50,7 +50,10 @@ if (process.server) {
 <template>
   <div>
     <div>data1: {{ data1 }}</div>
+
+    <!-- eslint-disable-next-line vue/singleline-html-element-content-newline -->
     <div id="immediate-data">{{ immediateFalseData === null ? "null" : (immediateFalseData === undefined ? 'undefined' : immediateFalseData) }}</div>
+
     <div>error1: {{ error1 }}</div>
     <div>error2: {{ error2 }}</div>
     <div>error3: {{ error3 }}</div>
diff --git a/test/bridge.test.ts b/test/bridge.test.ts
index 29368878..980c3488 100644
--- a/test/bridge.test.ts
+++ b/test/bridge.test.ts
@@ -78,7 +78,7 @@ describe('nuxt composables', () => {
   it('should render default value', async () => {
     const defaultValue = isV4 ? 'undefined' : 'null'
 
-    const { page } = await renderPage('/async-data');
+    const { page } = await renderPage('/async-data')
     expect(await page.locator('#immediate-data').getByText(defaultValue).textContent()).toBe(defaultValue)
 
     await page.close()

From 7bae15d07003fb53e48ff006a69e122118f99caa Mon Sep 17 00:00:00 2001
From: wattanx <wattan.dev@gmail.com>
Date: Sun, 7 Jul 2024 23:04:14 +0900
Subject: [PATCH 6/7] fix: useRoute fails with no-resolve

---
 playground/layouts/default.vue |  4 +---
 test/bridge.test.ts            | 13 ++++---------
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/playground/layouts/default.vue b/playground/layouts/default.vue
index acd2ba90..bfbf1d50 100644
--- a/playground/layouts/default.vue
+++ b/playground/layouts/default.vue
@@ -2,20 +2,18 @@
   <div>
     <Nuxt />
     <hr>
-    Route: {{ route.path }}
+    Route: {{ $route.path }}
   </div>
 </template>
 
 <script>
 export default {
   setup () {
-    const route = useRoute()
     useHead({
       titleTemplate (title) {
         return `${title} - Nuxt Bridge Playground`
       }
     })
-    return { route }
   }
 }
 </script>
diff --git a/test/bridge.test.ts b/test/bridge.test.ts
index 980c3488..67b1b6ce 100644
--- a/test/bridge.test.ts
+++ b/test/bridge.test.ts
@@ -43,7 +43,7 @@ describe('nuxt composables', () => {
   })
 
   // remove after port upstream.
-  it.skipIf((isWebpack && isNoResolve) || isDev)('updates cookies when they are changed', async () => {
+  it.skipIf(isDev)('updates cookies when they are changed', async () => {
     const { page } = await renderPage('/cookies')
     async function extractCookie () {
       const cookie = await page.evaluate(() => document.cookie)
@@ -137,9 +137,7 @@ describe('pages', () => {
 
     const { page, consoleLogs } = await renderPage('/')
 
-    if (isWebpack && isNoResolve) {
-      expect(consoleLogs.some(i => i.type === 'error')).toBeTruthy()
-    } else if (isDev) {
+    if (isDev) {
       // output [legacy capi] warning
       expect(consoleLogs.some(i => i.type === 'warning')).toBeTruthy()
     } else {
@@ -200,9 +198,7 @@ describe('navigate', () => {
 
     const { page, consoleLogs } = await renderPage('/navigate-to/')
 
-    if (isWebpack && isNoResolve) {
-      expect(consoleLogs.some(i => i.type === 'error')).toBeTruthy()
-    } else if (isDev) {
+    if (isDev) {
       // output [legacy capi] warning
       expect(consoleLogs.some(i => i.type === 'warning')).toBeTruthy()
     } else {
@@ -302,8 +298,7 @@ describe('middleware', () => {
     expect(html).toContain('Navigated successfully')
   })
 
-  // if `no-resolve`, an error occurs at `useRoute`.
-  it.skipIf(isWebpack && isNoResolve)('should be output with target as to and origin as from', async () => {
+  it('should be output with target as to and origin as from', async () => {
     const { page, consoleLogs } = await renderPage('/')
     await page.getByRole('link').click()
 

From 7f32d509ff57fbcb26e8a2059da6f4ab81ff8846 Mon Sep 17 00:00:00 2001
From: Rare Kang <7322570+serialine@users.noreply.github.com>
Date: Tue, 20 Aug 2024 06:24:04 +0900
Subject: [PATCH 7/7] feat: port `useNuxtData` composable (#1267)

Co-authored-by: rare <seungjin.kang@kreamcorp.com>
---
 packages/bridge/src/imports/presets.ts        |  2 +-
 .../src/runtime/composables/asyncData.ts      | 26 ++++++++++++++++++-
 .../bridge/src/runtime/composables/index.ts   |  2 +-
 playground/pages/async-data.vue               |  3 +++
 test/bridge.test.ts                           |  7 +++++
 5 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/packages/bridge/src/imports/presets.ts b/packages/bridge/src/imports/presets.ts
index 3ab869d7..2846478f 100644
--- a/packages/bridge/src/imports/presets.ts
+++ b/packages/bridge/src/imports/presets.ts
@@ -29,7 +29,7 @@ const granularAppPresets: InlinePreset[] = [
     from: '#app/composables/state'
   },
   {
-    imports: ['useLazyAsyncData', 'refreshNuxtData', 'clearNuxtData'],
+    imports: ['useLazyAsyncData', 'useNuxtData', 'refreshNuxtData', 'clearNuxtData'],
     from: '#app/composables/asyncData'
   },
   {
diff --git a/packages/bridge/src/runtime/composables/asyncData.ts b/packages/bridge/src/runtime/composables/asyncData.ts
index 54a38d95..86c4c257 100644
--- a/packages/bridge/src/runtime/composables/asyncData.ts
+++ b/packages/bridge/src/runtime/composables/asyncData.ts
@@ -1,4 +1,4 @@
-import { onBeforeMount, onServerPrefetch, onUnmounted, ref, shallowRef, getCurrentInstance, watch, toRef, unref, getCurrentScope, onScopeDispose } from 'vue'
+import { computed, onBeforeMount, onServerPrefetch, onUnmounted, ref, shallowRef, getCurrentInstance, watch, toRef, unref, getCurrentScope, onScopeDispose } from 'vue'
 import type { Ref, WatchSource } from 'vue'
 import type { NuxtAppCompat } from '@nuxt/bridge-schema'
 import { useNuxtApp } from '../nuxt'
@@ -396,6 +396,30 @@ export function useLazyAsyncData<
   return useAsyncData(key, handler, { ...options, lazy: true }, null)
 }
 
+export function useNuxtData<DataT = any> (key: string): { data: Ref<DataT | DefaultAsyncDataErrorValue> } {
+  const nuxtApp = useNuxtApp()
+
+  // Initialize value when key is not already set
+  if (!(key in nuxtApp.payload.data)) {
+    nuxtApp.payload.data[key] = undefined
+  }
+
+  return {
+    data: computed({
+      get () {
+        return nuxtApp._asyncData[key]?.data.value ?? nuxtApp.payload.data[key]
+      },
+      set (value) {
+        if (nuxtApp._asyncData[key]) {
+          nuxtApp._asyncData[key]!.data.value = value
+        } else {
+          nuxtApp.payload.data[key] = value
+        }
+      }
+    })
+  }
+}
+
 export function refreshNuxtData (keys?: string | string[]): Promise<void> {
   if (process.server) {
     return Promise.resolve()
diff --git a/packages/bridge/src/runtime/composables/index.ts b/packages/bridge/src/runtime/composables/index.ts
index d714fca4..9d509962 100644
--- a/packages/bridge/src/runtime/composables/index.ts
+++ b/packages/bridge/src/runtime/composables/index.ts
@@ -1,4 +1,4 @@
-export { useLazyAsyncData, refreshNuxtData, clearNuxtData } from './asyncData'
+export { useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData } from './asyncData'
 export * from './component'
 export { useCookie } from './cookie'
 export { clearError, createError, isNuxtError, throwError, showError, useError } from './error'
diff --git a/playground/pages/async-data.vue b/playground/pages/async-data.vue
index cf1192ab..5c70ba1e 100644
--- a/playground/pages/async-data.vue
+++ b/playground/pages/async-data.vue
@@ -45,6 +45,8 @@ if (process.server) {
   })
 }
 
+const { data: usedNuxtData } = useLazyAsyncData('nuxtData', () => Promise.resolve('helloNuxtData'))
+const { data: accessNuxtData } = useNuxtData('nuxtData')
 </script>
 
 <template>
@@ -59,5 +61,6 @@ if (process.server) {
     <div>error3: {{ error3 }}</div>
     <div>clearableData-1: {{ clearableData1?.text }}</div>
     <div>clearableData-2: {{ clearableData2?.text }}</div>
+    <div>usedNuxtData: {{ usedNuxtData }}, nuxtData: {{ accessNuxtData }}</div>
   </div>
 </template>
diff --git a/test/bridge.test.ts b/test/bridge.test.ts
index 67b1b6ce..42629628 100644
--- a/test/bridge.test.ts
+++ b/test/bridge.test.ts
@@ -75,6 +75,13 @@ describe('nuxt composables', () => {
     expect(html).not.toContain('clearableData-2: clearableData')
   })
 
+  it('should render text synced with useNuxtData', async () => {
+    const html = await $fetch('/async-data')
+    const expectedText = 'helloNuxtData'
+
+    expect(html).toContain(`usedNuxtData: ${expectedText}, nuxtData: ${expectedText}`)
+  })
+
   it('should render default value', async () => {
     const defaultValue = isV4 ? 'undefined' : 'null'