feat(useFsWatcher): support watching reactive arrayable patterns

Author: kermanx

packages/core/src/composables/useFsWatcher.ts

@@ -1,18 +1,64 @@
-import type { GlobPattern } from 'vscode'
+import type { MaybeRefOrGetter, ShallowReactive } from '@reactive-vscode/reactivity'
+import { onScopeDispose, shallowReactive, toValue, watchEffect } from '@reactive-vscode/reactivity'
+import type { Event, FileSystemWatcher, GlobPattern, Uri } from 'vscode'
 import { workspace } from 'vscode'
-import { useDisposable } from './useDisposable'
-import { useEvent } from './useEvent'
+import type { MaybeNullableRefOrGetter } from '../utils'
+import { useEventEmitter } from './useEventEmitter'
+
+export interface UseFSWatcher {
+  readonly watchers: ShallowReactive<Map<GlobPattern, FileSystemWatcher>>
+  readonly onDidCreate: Event<Uri>
+  readonly onDidChange: Event<Uri>
+  readonly onDidDelete: Event<Uri>
+}
 
 /**
  * @reactive `workspace.createFileSystemWatcher`
  */
-export function useFsWatcher(globPattern: GlobPattern, ignoreCreateEvents?: boolean | undefined, ignoreChangeEvents?: boolean | undefined, ignoreDeleteEvents?: boolean | undefined) {
-  const watcher = useDisposable(workspace.createFileSystemWatcher(globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents))
+export function useFsWatcher(
+  globPattern: MaybeRefOrGetter<GlobPattern | GlobPattern[]>,
+  ignoreCreateEvents?: MaybeNullableRefOrGetter<boolean>,
+  ignoreChangeEvents?: MaybeNullableRefOrGetter<boolean>,
+  ignoreDeleteEvents?: MaybeNullableRefOrGetter<boolean>,
+): UseFSWatcher {
+  const watchers = shallowReactive(new Map<GlobPattern, FileSystemWatcher>())
+  const createEmitter = useEventEmitter<Uri>()
+  const changeEmitter = useEventEmitter<Uri>()
+  const deleteEmitter = useEventEmitter<Uri>()
+
+  watchEffect(() => {
+    const globPatternValue = toValue(globPattern)
+    const newPatterns = Array.isArray(globPatternValue) ? globPatternValue : [globPatternValue]
+    for (const [pattern, watcher] of watchers) {
+      if (!newPatterns.includes(pattern)) {
+        watcher.dispose()
+      }
+    }
+    for (const pattern of newPatterns) {
+      if (!watchers.has(pattern)) {
+        const w = workspace.createFileSystemWatcher(
+          pattern,
+          toValue(ignoreCreateEvents) || false,
+          toValue(ignoreChangeEvents) || false,
+          toValue(ignoreDeleteEvents) || false,
+        )
+        w.onDidCreate(createEmitter.fire)
+        w.onDidChange(changeEmitter.fire)
+        w.onDidDelete(deleteEmitter.fire)
+      }
+    }
+  })
+
+  onScopeDispose(() => {
+    for (const watcher of watchers.values()) {
+      watcher.dispose()
+    }
+  })
 
   return {
-    ...watcher,
-    onDidCreate: useEvent(watcher.onDidCreate),
-    onDidChange: useEvent(watcher.onDidChange),
-    onDidDelete: useEvent(watcher.onDidDelete),
+    watchers,
+    onDidCreate: createEmitter.event,
+    onDidChange: changeEmitter.event,
+    onDidDelete: deleteEmitter.event,
   }
 }