Merge branch 'main' into feat/auth

Author: antfu

alias.ts

@@ -11,6 +11,8 @@ export const alias = {
   '@vitejs/devtools-rpc/presets/ws/client': r('rpc/src/presets/ws/client.ts'),
   '@vitejs/devtools-kit/client': r('kit/src/client/index.ts'),
   '@vitejs/devtools-kit/utils/events': r('kit/src/utils/events.ts'),
+  '@vitejs/devtools-kit/utils/nanoid': r('kit/src/utils/nanoid.ts'),
+  '@vitejs/devtools-kit/utils/shared-state': r('kit/src/utils/shared-state.ts'),
   '@vitejs/devtools-kit': r('kit/src/index.ts'),
   '@vitejs/devtools-vite': r('vite/src/index.ts'),
   '@vitejs/devtools/client/inject': r('core/src/client/inject/index.ts'),

packages/core/src/client/webcomponents/state/docks.ts

@@ -30,24 +30,36 @@ export function createDockEntryState(
     events: markRaw(events),
   })
 
-  watch(() => selected.value?.id, (newSelectedId) => {
-    if (newSelectedId === entry.id) {
-      events.emitOnce('entry:activated')
-    }
-    else {
-      events.emitOnce('entry:deactivated')
-    }
-  }, { immediate: true })
+  watch(
+    () => selected.value?.id,
+    (newSelectedId) => {
+      if (newSelectedId === entry.id) {
+        events.emit('entry:activated')
+      }
+      else {
+        events.emit('entry:deactivated')
+      }
+    },
+    { immediate: true },
+  )
 
-  watch(() => state.domElements.iframe, (newIframe) => {
-    if (newIframe)
-      events.emitOnce('dom:iframe:mounted', newIframe)
-  }, { immediate: true })
+  watch(
+    () => state.domElements.iframe,
+    (newIframe) => {
+      if (newIframe)
+        events.emit('dom:iframe:mounted', newIframe)
+    },
+    { immediate: true },
+  )
 
-  watch(() => state.domElements.panel, (newPanel) => {
-    if (newPanel)
-      events.emitOnce('dom:panel:mounted', newPanel)
-  }, { immediate: true })
+  watch(
+    () => state.domElements.panel,
+    (newPanel) => {
+      if (newPanel)
+        events.emit('dom:panel:mounted', newPanel)
+    },
+    { immediate: true },
+  )
 
   return state
 }

packages/core/src/node/context.ts

@@ -2,6 +2,7 @@ import type { DevToolsNodeContext } from '@vitejs/devtools-kit'
 import type { ResolvedConfig, ViteDevServer } from 'vite'
 import Debug from 'debug'
 import { debounce } from 'perfect-debounce'
+import { searchForWorkspaceRoot } from 'vite'
 import { ContextUtils } from './context-utils'
 import { DevToolsDockHost } from './host-docks'
 import { RpcFunctionsHost } from './host-functions'
@@ -19,6 +20,7 @@ export async function createDevToolsContext(
 
   const context: DevToolsNodeContext = {
     cwd,
+    workspaceRoot: searchForWorkspaceRoot(cwd) ?? cwd,
     viteConfig,
     viteServer,
     mode: viteConfig.command === 'serve' ? 'dev' : 'build',

packages/core/src/node/storage.ts

@@ -0,0 +1,28 @@
+import fs from 'node:fs'
+import { createSharedState } from '@vitejs/devtools-kit/utils/shared-state'
+
+export interface CreateStorageOptions<T extends object> {
+  filepath: string
+  initialValue: T
+}
+
+export async function createStorage<T extends object>(options: CreateStorageOptions<T>) {
+  let initialState: T
+  if (fs.existsSync(options.filepath)) {
+    initialState = JSON.parse(await fs.readFileSync(options.filepath, 'utf-8')) as T
+  }
+  else {
+    initialState = options.initialValue
+  }
+
+  const state = createSharedState<T>({
+    initialState,
+    enablePatches: false,
+  })
+
+  state.on('updated', (newState) => {
+    fs.writeFileSync(options.filepath, `${JSON.stringify(newState, null, 2)}\n`)
+  })
+
+  return state
+}

packages/kit/package.json

@@ -23,6 +23,7 @@
     "./client": "./dist/client.mjs",
     "./utils/events": "./dist/utils/events.mjs",
     "./utils/nanoid": "./dist/utils/nanoid.mjs",
+    "./utils/shared-state": "./dist/utils/shared-state.mjs",
     "./package.json": "./package.json"
   },
   "main": "./dist/index.mjs",

packages/kit/src/types/vite-plugin.ts

@@ -19,6 +19,10 @@ export interface DevToolsPluginOptions {
 }
 
 export interface DevToolsNodeContext {
+  /**
+   * Workspace root directory of Vite DevTools
+   */
+  readonly workspaceRoot: string
   /**
    * Current working directory of Vite DevTools
    */

packages/kit/src/utils/shared-state.ts

@@ -0,0 +1,89 @@
+import type { Objectish, Patch } from 'immer'
+import type { EventEmitter } from '../types/events'
+import { applyPatches, produce, produceWithPatches } from 'immer'
+import { createEventEmitter } from './events'
+
+// eslint-disable-next-line ts/no-unsafe-function-type
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function
+
+export type Immutable<T>
+  = T extends ImmutablePrimitive ? T
+    : T extends Array<infer U> ? ImmutableArray<U>
+      : T extends Map<infer K, infer V> ? ImmutableMap<K, V>
+        : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>
+
+export type ImmutableArray<T> = ReadonlyArray<Immutable<T>>
+export type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>
+export type ImmutableSet<T> = ReadonlySet<Immutable<T>>
+export type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> }
+
+/**
+ * State host that is immutable by default with explicit mutate.
+ */
+export interface SharedState<T> {
+  /**
+   * Get the current state. Immutable.
+   */
+  get: () => Immutable<T>
+  /**
+   * Subscribe to state changes.
+   */
+  on: EventEmitter<SharedStateEvents<T>>['on']
+  /**
+   * Mutate the state.
+   */
+  mutate: (fn: (state: T) => void) => void
+  /**
+   * Apply patches to the state.
+   */
+  patch: (patches: Patch[]) => void
+}
+
+export interface SharedStateEvents<T> {
+  updated: (state: T) => void
+  patches: (patches: Patch[]) => void
+}
+
+export interface SharedStateOptions<T> {
+  /**
+   * Initial state.
+   */
+  initialState: T
+  /**
+   * Enable patches.
+   *
+   * @default false
+   */
+  enablePatches?: boolean
+}
+
+export function createSharedState<T extends Objectish>(
+  options: SharedStateOptions<T>,
+): SharedState<T> {
+  const {
+    enablePatches = false,
+  } = options
+
+  const events = createEventEmitter<SharedStateEvents<T>>()
+  let state = options.initialState
+
+  return {
+    on: events.on,
+    get: () => state as Immutable<T>,
+    patch: (patches: Patch[]) => {
+      state = applyPatches<T>(state, patches)
+      events.emit('updated', state)
+    },
+    mutate: (fn) => {
+      if (enablePatches) {
+        const [newState, patches] = produceWithPatches(state, fn)
+        state = newState
+        events.emit('patches', patches)
+      }
+      else {
+        state = produce(state, fn)
+      }
+      events.emit('updated', state)
+    },
+  }
+}

packages/kit/tsdown.config.ts

@@ -5,6 +5,7 @@ export default defineConfig({
     'index': 'src/index.ts',
     'utils/events': 'src/utils/events.ts',
     'utils/nanoid': 'src/utils/nanoid.ts',
+    'utils/shared-state': 'src/utils/shared-state.ts',
     'client': 'src/client/index.ts',
   },
   exports: true,

tsconfig.base.json

@@ -24,6 +24,12 @@
       "@vitejs/devtools-kit/utils/events": [
         "./packages/kit/src/utils/events.ts"
       ],
+      "@vitejs/devtools-kit/utils/nanoid": [
+        "./packages/kit/src/utils/nanoid.ts"
+      ],
+      "@vitejs/devtools-kit/utils/shared-state": [
+        "./packages/kit/src/utils/shared-state.ts"
+      ],
       "@vitejs/devtools-kit": [
         "./packages/kit/src/index.ts"
       ],