refactor: rename to onWatcherCleanup, getCurrentWatcher, remove middleware

LittleSound · LittleSound · commit 369474522926 · 2024-03-12T18:16:52.000+08:00
diff --git a/packages/reactivity/__tests__/baseWatch.spec.ts b/packages/reactivity/__tests__/baseWatch.spec.ts
@@ -4,9 +4,9 @@ import {
   EffectScope,
   type Ref,
   baseWatch,
+  onWatcherCleanup,
   ref,
 } from '../src'
-import { onEffectCleanup } from '../src/effect'
 
 const queue: SchedulerJob[] = []
 
@@ -67,7 +67,7 @@ describe('baseWatch', () => {
     const effect = baseWatch(
       source,
       () => {
-        onEffectCleanup(() => {
+        onWatcherCleanup(() => {
           throw 'oops in cleanup'
         })
         throw 'oops in watch'
@@ -108,8 +108,8 @@ describe('baseWatch', () => {
         source.value
 
         onCleanup(() => (dummy += 2))
-        onEffectCleanup(() => (dummy += 3))
-        onEffectCleanup(() => (dummy += 5))
+        onWatcherCleanup(() => (dummy += 3))
+        onWatcherCleanup(() => (dummy += 5))
       })
     })
     expect(dummy).toBe(0)
@@ -141,7 +141,7 @@ describe('baseWatch', () => {
       baseWatch(
         () => {
           const current = (copyist.value = source.value)
-          onEffectCleanup(() => calls.push(`sync ${current}`))
+          onWatcherCleanup(() => calls.push(`sync ${current}`))
         },
         null,
         {},
@@ -150,7 +150,7 @@ describe('baseWatch', () => {
       baseWatch(
         () => {
           const current = copyist.value
-          onEffectCleanup(() => calls.push(`post ${current}`))
+          onWatcherCleanup(() => calls.push(`post ${current}`))
         },
         null,
         { scheduler },
@@ -175,82 +175,4 @@ describe('baseWatch', () => {
     scope.stop()
     expect(calls).toEqual(['sync 2', 'post 2'])
   })
-  test('baseWatch with middleware', async () => {
-    let effectCalls: string[] = []
-    let watchCalls: string[] = []
-    const source = ref(0)
-
-    // effect
-    baseWatch(
-      () => {
-        source.value
-        effectCalls.push('effect')
-        onEffectCleanup(() => effectCalls.push('effect cleanup'))
-      },
-      null,
-      {
-        scheduler,
-        middleware: next => {
-          effectCalls.push('before effect running')
-          next()
-          effectCalls.push('effect ran')
-        },
-      },
-    )
-    // watch
-    baseWatch(
-      () => source.value,
-      () => {
-        watchCalls.push('watch')
-        onEffectCleanup(() => watchCalls.push('watch cleanup'))
-      },
-      {
-        scheduler,
-        middleware: next => {
-          watchCalls.push('before watch running')
-          next()
-          watchCalls.push('watch ran')
-        },
-      },
-    )
-
-    expect(effectCalls).toEqual([])
-    expect(watchCalls).toEqual([])
-    await nextTick()
-    expect(effectCalls).toEqual([
-      'before effect running',
-      'effect',
-      'effect ran',
-    ])
-    expect(watchCalls).toEqual([])
-    effectCalls.length = 0
-    watchCalls.length = 0
-
-    source.value++
-    await nextTick()
-    expect(effectCalls).toEqual([
-      'before effect running',
-      'effect cleanup',
-      'effect',
-      'effect ran',
-    ])
-    expect(watchCalls).toEqual(['before watch running', 'watch', 'watch ran'])
-    effectCalls.length = 0
-    watchCalls.length = 0
-
-    source.value++
-    await nextTick()
-    expect(effectCalls).toEqual([
-      'before effect running',
-      'effect cleanup',
-      'effect',
-      'effect ran',
-    ])
-    expect(watchCalls).toEqual([
-      'before watch running',
-      'watch cleanup',
-      'watch',
-      'watch ran',
-    ])
-  })
 })
diff --git a/packages/reactivity/src/baseWatch.ts b/packages/reactivity/src/baseWatch.ts
@@ -79,7 +79,6 @@ export interface BaseWatchOptions<Immediate = boolean> extends DebuggerOptions {
   deep?: boolean
   once?: boolean
   scheduler?: Scheduler
-  middleware?: BaseWatchMiddleware
   onError?: HandleError
   onWarn?: HandleWarn
 }
@@ -92,7 +91,6 @@ export type Scheduler = (
   effect: ReactiveEffect,
   isInit: boolean,
 ) => void
-export type BaseWatchMiddleware = (next: () => unknown) => any
 export type HandleError = (err: unknown, type: BaseWatchErrorCodes) => void
 export type HandleWarn = (msg: string, ...args: any[]) => void
 
@@ -102,13 +100,13 @@ const DEFAULT_HANDLE_ERROR: HandleError = (err: unknown) => {
 }
 
 const cleanupMap: WeakMap<ReactiveEffect, (() => void)[]> = new WeakMap()
-let activeEffect: ReactiveEffect | undefined = undefined
+let activeWatcher: ReactiveEffect | undefined = undefined
 
 /**
  * Returns the current active effect if there is one.
  */
-export function getCurrentEffect() {
-  return activeEffect
+export function getCurrentWatcher() {
+  return activeWatcher
 }
 
 /**
@@ -118,15 +116,15 @@ export function getCurrentEffect() {
  *
  * @param cleanupFn - The callback function to attach to the effect's cleanup.
  */
-export function onEffectCleanup(cleanupFn: () => void) {
-  if (activeEffect) {
+export function onWatcherCleanup(cleanupFn: () => void, failSilently = false) {
+  if (activeWatcher) {
     const cleanups =
-      cleanupMap.get(activeEffect) ||
-      cleanupMap.set(activeEffect, []).get(activeEffect)!
+      cleanupMap.get(activeWatcher) ||
+      cleanupMap.set(activeWatcher, []).get(activeWatcher)!
     cleanups.push(cleanupFn)
-  } else if (__DEV__) {
+  } else if (__DEV__ && !failSilently) {
     warn(
-      `onEffectCleanup() was called when there was no active effect` +
+      `onWatcherCleanup() was called when there was no active watcher` +
         ` to associate with.`,
     )
   }
@@ -142,7 +140,6 @@ export function baseWatch(
     scheduler = DEFAULT_SCHEDULER,
     onWarn = __DEV__ ? warn : NOOP,
     onError = DEFAULT_HANDLE_ERROR,
-    middleware,
     onTrack,
     onTrigger,
   }: BaseWatchOptions = EMPTY_OBJ,
@@ -209,23 +206,19 @@ export function baseWatch(
             resetTracking()
           }
         }
-        const currentEffect = activeEffect
-        activeEffect = effect
+        const currentEffect = activeWatcher
+        activeWatcher = effect
         try {
           return callWithAsyncErrorHandling(
             source,
             onError,
             BaseWatchErrorCodes.WATCH_CALLBACK,
-            [onEffectCleanup],
+            [onWatcherCleanup],
           )
         } finally {
-          activeEffect = currentEffect
+          activeWatcher = currentEffect
         }
       }
-      if (middleware) {
-        const baseGetter = getter
-        getter = () => middleware(baseGetter)
-      }
     }
   } else {
     getter = NOOP
@@ -239,19 +232,19 @@ export function baseWatch(
 
   if (once) {
     if (!cb) {
-      // onEffectCleanup need use effect as a key
+      // onWatcherCleanup need use effect as a key
       getCurrentScope()?.effects.push((effect = {} as any))
       getter()
       return
     }
     if (immediate) {
-      // onEffectCleanup need use effect as a key
+      // onWatcherCleanup need use effect as a key
       getCurrentScope()?.effects.push((effect = {} as any))
       callWithAsyncErrorHandling(
         cb,
         onError,
         BaseWatchErrorCodes.WATCH_CALLBACK,
-        [getter(), isMultiSource ? [] : undefined, onEffectCleanup],
+        [getter(), isMultiSource ? [] : undefined, onWatcherCleanup],
       )
       return
     }
@@ -282,38 +275,31 @@ export function baseWatch(
           ? (newValue as any[]).some((v, i) => hasChanged(v, oldValue[i]))
           : hasChanged(newValue, oldValue))
       ) {
-        const next = () => {
-          // cleanup before running cb again
-          if (cleanup) {
-            cleanup()
-          }
-          const currentEffect = activeEffect
-          activeEffect = effect
-          try {
-            callWithAsyncErrorHandling(
-              cb!,
-              onError,
-              BaseWatchErrorCodes.WATCH_CALLBACK,
-              [
-                newValue,
-                // pass undefined as the old value when it's changed for the first time
-                oldValue === INITIAL_WATCHER_VALUE
-                  ? undefined
-                  : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE
-                    ? []
-                    : oldValue,
-                onEffectCleanup,
-              ],
-            )
-            oldValue = newValue
-          } finally {
-            activeEffect = currentEffect
-          }
+        // cleanup before running cb again
+        if (cleanup) {
+          cleanup()
         }
-        if (middleware) {
-          middleware(next)
-        } else {
-          next()
+        const currentWatcher = activeWatcher
+        activeWatcher = effect
+        try {
+          callWithAsyncErrorHandling(
+            cb!,
+            onError,
+            BaseWatchErrorCodes.WATCH_CALLBACK,
+            [
+              newValue,
+              // pass undefined as the old value when it's changed for the first time
+              oldValue === INITIAL_WATCHER_VALUE
+                ? undefined
+                : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE
+                  ? []
+                  : oldValue,
+              onWatcherCleanup,
+            ],
+          )
+          oldValue = newValue
+        } finally {
+          activeWatcher = currentWatcher
         }
       }
     } else {
diff --git a/packages/reactivity/src/index.ts b/packages/reactivity/src/index.ts
@@ -79,10 +79,10 @@ export { reactiveReadArray, shallowReadArray } from './arrayInstrumentations'
 export { TrackOpTypes, TriggerOpTypes, ReactiveFlags } from './constants'
 export {
   baseWatch,
-  getCurrentEffect,
+  getCurrentWatcher as getCurrentEffect,
   traverse,
+  onWatcherCleanup,
   BaseWatchErrorCodes,
   type BaseWatchOptions,
-  type BaseWatchMiddleware,
   type Scheduler,
 } from './baseWatch'
