1export interface ReactiveEffectOptions extends DebuggerOptions {
2  lazy?: boolean
3  scheduler?: EffectScheduler
4  scope?: EffectScope
5  allowRecurse?: boolean
6  onStop?: () => void
7}
8
9export interface ReactiveEffectRunner<T = any> {
10  (): T
11  effect: ReactiveEffect
12}
13
14/**
15 * Registers the given function to track reactive updates.
16 *
17 * The given function will be run once immediately. Every time any reactive
18 * property that's accessed within it gets updated, the function will run again.
19 *
20 * @param fn - The function that will track reactive updates.
21 * @param options - Allows to control the effect's behaviour.
22 * @returns A runner that can be used to control the effect after creation.
23 */
24export function effect<T = any>(
25  fn: () => T,
26  options?: ReactiveEffectOptions,
27): ReactiveEffectRunner {
28  /// ...
29
30  const _effect = new ReactiveEffect(fn, NOOP, () => {
31    if (_effect.dirty) {
32      _effect.run()
33    }
34  })
35  /// ...
36  if (!options || !options.lazy) {
37    _effect.run()
38  }
39  const runner = _effect.run.bind(_effect) as ReactiveEffectRunner
40  runner.effect = _effect
41  return runner
42}

1export interface ReactiveEffectRunner<T = any> {
2  (): T
3  effect: ReactiveEffect
4}

1export type Dep = Map<ReactiveEffect, number> & {
2  cleanup: () => void
3  computed?: ComputedRefImpl<any>
4}
5
6export let activeEffect: ReactiveEffect | undefined
7
8export class ReactiveEffect<T = any> {
9  /// ...
10  deps: Dep[] = []
11  /// ...
12
13  constructor(
14    public fn: () => T,
15    public trigger: () => void,
16    public scheduler?: EffectScheduler,
17    scope?: EffectScope,
18  ) {
19    /// ...
20  }
21
22  public get dirty() {
23    /// ...
24  }
25
26  public set dirty(v) {
27    /// ...
28  }
29
30  run() {
31    /// ...
32    let lastEffect = activeEffect
33    try {
34      shouldTrack = true
35      activeEffect = this
36      this._runnings++
37      preCleanupEffect(this)
38      return this.fn()
39    } finally {
40      postCleanupEffect(this)
41      this._runnings--
42      activeEffect = lastEffect
43      shouldTrack = lastShouldTrack
44    }
45  }
46
47  stop() {
48    /// ...
49  }
50}