@vue/reactivity 3.5.17 → 3.6.0-alpha.2

package/dist/reactivity.d.ts

@@ -11,7 +11,7 @@ export declare enum TriggerOpTypes {
     DELETE = "delete",
     CLEAR = "clear"
 }
-export declare enum ReactiveFlags {
+export declare enum ReactiveFlags$1 {
     SKIP = "__v_skip",
     IS_REACTIVE = "__v_isReactive",
     IS_READONLY = "__v_isReadonly",
@@ -20,6 +20,238 @@ export declare enum ReactiveFlags {
     IS_REF = "__v_isRef"
 }
 
+export declare class EffectScope implements ReactiveNode {
+    deps: Link | undefined;
+    depsTail: Link | undefined;
+    subs: Link | undefined;
+    subsTail: Link | undefined;
+    flags: number;
+    constructor(detached?: boolean);
+    get active(): boolean;
+    pause(): void;
+    /**
+     * Resumes the effect scope, including all child scopes and effects.
+     */
+    resume(): void;
+    run<T>(fn: () => T): T | undefined;
+    stop(): void;
+}
+/**
+ * Creates an effect scope object which can capture the reactive effects (i.e.
+ * computed and watchers) created within it so that these effects can be
+ * disposed together. For detailed use cases of this API, please consult its
+ * corresponding {@link https://github.com/vuejs/rfcs/blob/master/active-rfcs/0041-reactivity-effect-scope.md | RFC}.
+ *
+ * @param detached - Can be used to create a "detached" effect scope.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#effectscope}
+ */
+export declare function effectScope(detached?: boolean): EffectScope;
+/**
+ * Returns the current active effect scope if there is one.
+ *
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#getcurrentscope}
+ */
+export declare function getCurrentScope(): EffectScope | undefined;
+export declare function setCurrentScope(scope?: EffectScope): EffectScope | undefined;
+/**
+ * Registers a dispose callback on the current active effect scope. The
+ * callback will be invoked when the associated effect scope is stopped.
+ *
+ * @param fn - The callback function to attach to the scope's cleanup.
+ * @see {@link https://vuejs.org/api/reactivity-advanced.html#onscopedispose}
+ */
+export declare function onScopeDispose(fn: () => void, failSilently?: boolean): void;
+
+interface ReactiveNode {
+    deps?: Link;
+    depsTail?: Link;
+    subs?: Link;
+    subsTail?: Link;
+    flags: ReactiveFlags;
+}
+interface Link {
+    dep: ReactiveNode | ComputedRefImpl | ReactiveEffect | EffectScope;
+    sub: ReactiveNode | ComputedRefImpl | ReactiveEffect | EffectScope;
+    prevSub: Link | undefined;
+    nextSub: Link | undefined;
+    prevDep: Link | undefined;
+    nextDep: Link | undefined;
+}
+declare const enum ReactiveFlags {
+    None = 0,
+    Mutable = 1,
+    Watching = 2,
+    RecursedCheck = 4,
+    Recursed = 8,
+    Dirty = 16,
+    Pending = 32
+}
+
+export type EffectScheduler = (...args: any[]) => any;
+export type DebuggerEvent = {
+    effect: ReactiveNode;
+} & DebuggerEventExtraInfo;
+export type DebuggerEventExtraInfo = {
+    target: object;
+    type: TrackOpTypes | TriggerOpTypes;
+    key: any;
+    newValue?: any;
+    oldValue?: any;
+    oldTarget?: Map<any, any> | Set<any>;
+};
+export interface DebuggerOptions {
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+}
+export interface ReactiveEffectOptions extends DebuggerOptions {
+    scheduler?: EffectScheduler;
+    onStop?: () => void;
+}
+export declare enum EffectFlags {
+    /**
+     * ReactiveEffect only
+     */
+    ALLOW_RECURSE = 128,
+    PAUSED = 256,
+    STOP = 1024
+}
+export declare class ReactiveEffect<T = any> implements ReactiveEffectOptions, ReactiveNode {
+    deps: Link | undefined;
+    depsTail: Link | undefined;
+    subs: Link | undefined;
+    subsTail: Link | undefined;
+    flags: number;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    fn(): T;
+    constructor(fn?: () => T);
+    get active(): boolean;
+    pause(): void;
+    resume(): void;
+    notify(): void;
+    run(): T;
+    stop(): void;
+    get dirty(): boolean;
+}
+export interface ReactiveEffectRunner<T = any> {
+    (): T;
+    effect: ReactiveEffect;
+}
+export interface ReactiveEffectRunner<T = any> {
+    (): T;
+    effect: ReactiveEffect;
+}
+export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner<T>;
+/**
+ * Stops the effect associated with the given runner.
+ *
+ * @param runner - Association with the effect to stop tracking.
+ */
+export declare function stop(runner: ReactiveEffectRunner): void;
+/**
+ * Temporarily pauses tracking.
+ */
+export declare function pauseTracking(): void;
+/**
+ * Re-enables effect tracking (if it was paused).
+ */
+export declare function enableTracking(): void;
+/**
+ * Resets the previous global effect tracking state.
+ */
+export declare function resetTracking(): void;
+/**
+ * Registers a cleanup function for the current active effect.
+ * The cleanup function is called right before the next effect run, or when the
+ * effect is stopped.
+ *
+ * Throws a warning if there is no current active effect. The warning can be
+ * suppressed by passing `true` to the second argument.
+ *
+ * @param fn - the cleanup function to be registered
+ * @param failSilently - if `true`, will not throw warning when called without
+ * an active effect.
+ */
+export declare function onEffectCleanup(fn: () => void, failSilently?: boolean): void;
+
+declare const ComputedRefSymbol: unique symbol;
+declare const WritableComputedRefSymbol: unique symbol;
+interface BaseComputedRef<T, S = T> extends Ref<T, S> {
+    [ComputedRefSymbol]: true;
+    /**
+     * @deprecated computed no longer uses effect
+     */
+    effect: ComputedRefImpl;
+}
+export interface ComputedRef<T = any> extends BaseComputedRef<T> {
+    readonly value: T;
+}
+export interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {
+    [WritableComputedRefSymbol]: true;
+}
+export type ComputedGetter<T> = (oldValue?: T) => T;
+export type ComputedSetter<T> = (newValue: T) => void;
+export interface WritableComputedOptions<T, S = T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<S>;
+}
+/**
+ * @private exported by @vue/reactivity for Vue core use, but not exported from
+ * the main vue package
+ */
+export declare class ComputedRefImpl<T = any> implements ReactiveNode {
+    fn: ComputedGetter<T>;
+    private readonly setter;
+    subs: Link | undefined;
+    subsTail: Link | undefined;
+    deps: Link | undefined;
+    depsTail: Link | undefined;
+    flags: ReactiveFlags;
+    get effect(): this;
+    get dep(): ReactiveNode;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    constructor(fn: ComputedGetter<T>, setter: ComputedSetter<T> | undefined);
+    get value(): T;
+    set value(newValue: T);
+    update(): boolean;
+}
+/**
+ * Takes a getter function and returns a readonly reactive ref object for the
+ * returned value from the getter. It can also take an object with get and set
+ * functions to create a writable ref object.
+ *
+ * @example
+ * ```js
+ * // Creating a readonly computed ref:
+ * const count = ref(1)
+ * const plusOne = computed(() => count.value + 1)
+ *
+ * console.log(plusOne.value) // 2
+ * plusOne.value++ // error
+ * ```
+ *
+ * ```js
+ * // Creating a writable computed ref:
+ * const count = ref(1)
+ * const plusOne = computed({
+ *   get: () => count.value + 1,
+ *   set: (val) => {
+ *     count.value = val - 1
+ *   }
+ * })
+ *
+ * plusOne.value = 1
+ * console.log(count.value) // 0
+ * ```
+ *
+ * @param getter - Function that produces the next value.
+ * @param debugOptions - For debugging. See {@link https://vuejs.org/guide/extras/reactivity-in-depth.html#computed-debugging}.
+ * @see {@link https://vuejs.org/api/reactivity-core.html#computed}
+ */
+export declare function computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
+export declare function computed<T, S = T>(options: WritableComputedOptions<T, S>, debugOptions?: DebuggerOptions): WritableComputedRef<T, S>;
+
 export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
 declare const ReactiveMarkerSymbol: unique symbol;
 export interface ReactiveMarker {
@@ -250,171 +482,6 @@ export declare const toReactive: <T extends unknown>(value: T) => T;
  */
 export declare const toReadonly: <T extends unknown>(value: T) => DeepReadonly<T>;
 
-export type EffectScheduler = (...args: any[]) => any;
-export type DebuggerEvent = {
-    effect: Subscriber;
-} & DebuggerEventExtraInfo;
-export type DebuggerEventExtraInfo = {
-    target: object;
-    type: TrackOpTypes | TriggerOpTypes;
-    key: any;
-    newValue?: any;
-    oldValue?: any;
-    oldTarget?: Map<any, any> | Set<any>;
-};
-export interface DebuggerOptions {
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-}
-export interface ReactiveEffectOptions extends DebuggerOptions {
-    scheduler?: EffectScheduler;
-    allowRecurse?: boolean;
-    onStop?: () => void;
-}
-export declare enum EffectFlags {
-    /**
-     * ReactiveEffect only
-     */
-    ACTIVE = 1,
-    RUNNING = 2,
-    TRACKING = 4,
-    NOTIFIED = 8,
-    DIRTY = 16,
-    ALLOW_RECURSE = 32,
-    PAUSED = 64,
-    EVALUATED = 128
-}
-/**
- * Subscriber is a type that tracks (or subscribes to) a list of deps.
- */
-interface Subscriber extends DebuggerOptions {
-}
-export declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
-    fn: () => T;
-    scheduler?: EffectScheduler;
-    onStop?: () => void;
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-    constructor(fn: () => T);
-    pause(): void;
-    resume(): void;
-    run(): T;
-    stop(): void;
-    trigger(): void;
-    get dirty(): boolean;
-}
-export interface ReactiveEffectRunner<T = any> {
-    (): T;
-    effect: ReactiveEffect;
-}
-export interface ReactiveEffectRunner<T = any> {
-    (): T;
-    effect: ReactiveEffect;
-}
-export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner<T>;
-/**
- * Stops the effect associated with the given runner.
- *
- * @param runner - Association with the effect to stop tracking.
- */
-export declare function stop(runner: ReactiveEffectRunner): void;
-/**
- * Temporarily pauses tracking.
- */
-export declare function pauseTracking(): void;
-/**
- * Re-enables effect tracking (if it was paused).
- */
-export declare function enableTracking(): void;
-/**
- * Resets the previous global effect tracking state.
- */
-export declare function resetTracking(): void;
-/**
- * Registers a cleanup function for the current active effect.
- * The cleanup function is called right before the next effect run, or when the
- * effect is stopped.
- *
- * Throws a warning if there is no current active effect. The warning can be
- * suppressed by passing `true` to the second argument.
- *
- * @param fn - the cleanup function to be registered
- * @param failSilently - if `true`, will not throw warning when called without
- * an active effect.
- */
-export declare function onEffectCleanup(fn: () => void, failSilently?: boolean): void;
-
-declare const ComputedRefSymbol: unique symbol;
-declare const WritableComputedRefSymbol: unique symbol;
-interface BaseComputedRef<T, S = T> extends Ref<T, S> {
-    [ComputedRefSymbol]: true;
-    /**
-     * @deprecated computed no longer uses effect
-     */
-    effect: ComputedRefImpl;
-}
-export interface ComputedRef<T = any> extends BaseComputedRef<T> {
-    readonly value: T;
-}
-export interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {
-    [WritableComputedRefSymbol]: true;
-}
-export type ComputedGetter<T> = (oldValue?: T) => T;
-export type ComputedSetter<T> = (newValue: T) => void;
-export interface WritableComputedOptions<T, S = T> {
-    get: ComputedGetter<T>;
-    set: ComputedSetter<S>;
-}
-/**
- * @private exported by @vue/reactivity for Vue core use, but not exported from
- * the main vue package
- */
-export declare class ComputedRefImpl<T = any> implements Subscriber {
-    fn: ComputedGetter<T>;
-    private readonly setter;
-    effect: this;
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-    constructor(fn: ComputedGetter<T>, setter: ComputedSetter<T> | undefined, isSSR: boolean);
-    get value(): T;
-    set value(newValue: T);
-}
-/**
- * Takes a getter function and returns a readonly reactive ref object for the
- * returned value from the getter. It can also take an object with get and set
- * functions to create a writable ref object.
- *
- * @example
- * ```js
- * // Creating a readonly computed ref:
- * const count = ref(1)
- * const plusOne = computed(() => count.value + 1)
- *
- * console.log(plusOne.value) // 2
- * plusOne.value++ // error
- * ```
- *
- * ```js
- * // Creating a writable computed ref:
- * const count = ref(1)
- * const plusOne = computed({
- *   get: () => count.value + 1,
- *   set: (val) => {
- *     count.value = val - 1
- *   }
- * })
- *
- * plusOne.value = 1
- * console.log(count.value) // 0
- * ```
- *
- * @param getter - Function that produces the next value.
- * @param debugOptions - For debugging. See {@link https://vuejs.org/guide/extras/reactivity-in-depth.html#computed-debugging}.
- * @see {@link https://vuejs.org/api/reactivity-core.html#computed}
- */
-export declare function computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
-export declare function computed<T, S = T>(options: WritableComputedOptions<T, S>, debugOptions?: DebuggerOptions): WritableComputedRef<T, S>;
-
 declare const RefSymbol: unique symbol;
 declare const RawSymbol: unique symbol;
 export interface Ref<T = any, S = T> {
@@ -662,45 +729,6 @@ export declare function track(target: object, type: TrackOpTypes, key: unknown):
  */
 export declare function trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;
 
-export declare class EffectScope {
-    detached: boolean;
-    private _isPaused;
-    constructor(detached?: boolean);
-    get active(): boolean;
-    pause(): void;
-    /**
-     * Resumes the effect scope, including all child scopes and effects.
-     */
-    resume(): void;
-    run<T>(fn: () => T): T | undefined;
-    prevScope: EffectScope | undefined;
-    stop(fromParent?: boolean): void;
-}
-/**
- * Creates an effect scope object which can capture the reactive effects (i.e.
- * computed and watchers) created within it so that these effects can be
- * disposed together. For detailed use cases of this API, please consult its
- * corresponding {@link https://github.com/vuejs/rfcs/blob/master/active-rfcs/0041-reactivity-effect-scope.md | RFC}.
- *
- * @param detached - Can be used to create a "detached" effect scope.
- * @see {@link https://vuejs.org/api/reactivity-advanced.html#effectscope}
- */
-export declare function effectScope(detached?: boolean): EffectScope;
-/**
- * Returns the current active effect scope if there is one.
- *
- * @see {@link https://vuejs.org/api/reactivity-advanced.html#getcurrentscope}
- */
-export declare function getCurrentScope(): EffectScope | undefined;
-/**
- * Registers a dispose callback on the current active effect scope. The
- * callback will be invoked when the associated effect scope is stopped.
- *
- * @param fn - The callback function to attach to the scope's cleanup.
- * @see {@link https://vuejs.org/api/reactivity-advanced.html#onscopedispose}
- */
-export declare function onScopeDispose(fn: () => void, failSilently?: boolean): void;
-
 /**
  * Track array iteration and return:
  * - if input is reactive: a cloned raw array with reactive values
@@ -725,7 +753,6 @@ export interface WatchOptions<Immediate = boolean> extends DebuggerOptions {
     immediate?: Immediate;
     deep?: boolean | number;
     once?: boolean;
-    scheduler?: WatchScheduler;
     onWarn?: (msg: string, ...args: any[]) => void;
 }
 export type WatchStopHandle = () => void;
@@ -734,7 +761,6 @@ export interface WatchHandle extends WatchStopHandle {
     resume: () => void;
     stop: () => void;
 }
-export type WatchScheduler = (job: () => void, isFirstRun: boolean) => void;
 /**
  * Returns the current active effect if there is one.
  */
@@ -750,8 +776,18 @@ export declare function getCurrentWatcher(): ReactiveEffect<any> | undefined;
  * @param owner - The effect that this cleanup function should be attached to.
  * By default, the current active effect.
  */
-export declare function onWatcherCleanup(cleanupFn: () => void, failSilently?: boolean, owner?: ReactiveEffect | undefined): void;
+export declare function onWatcherCleanup(cleanupFn: () => void, failSilently?: boolean, owner?: WatcherEffect | undefined): void;
+export declare class WatcherEffect extends ReactiveEffect {
+    cb?: WatchCallback<any, any> | null | undefined;
+    options: WatchOptions;
+    forceTrigger: boolean;
+    isMultiSource: boolean;
+    oldValue: any;
+    boundCleanup: typeof onWatcherCleanup;
+    constructor(source: WatchSource | WatchSource[] | WatchEffect | object, cb?: WatchCallback<any, any> | null | undefined, options?: WatchOptions);
+    run(initialRun?: boolean): void;
+}
 export declare function watch(source: WatchSource | WatchSource[] | WatchEffect | object, cb?: WatchCallback | null, options?: WatchOptions): WatchHandle;
 export declare function traverse(value: unknown, depth?: number, seen?: Set<unknown>): unknown;
 
-
+export { ReactiveFlags$1 as ReactiveFlags,  };