@vue/reactivity 3.3.6 → 3.4.0-alpha.1

package/dist/reactivity.d.ts

@@ -1,5 +1,16 @@
 import { IfAny } from '@vue/shared';
 
+export declare const enum TrackOpTypes {
+    GET = "get",
+    HAS = "has",
+    ITERATE = "iterate"
+}
+export declare const enum TriggerOpTypes {
+    SET = "set",
+    ADD = "add",
+    DELETE = "delete",
+    CLEAR = "clear"
+}
 export declare const enum ReactiveFlags {
     SKIP = "__v_skip",
     IS_REACTIVE = "__v_isReactive",
@@ -7,6 +18,7 @@ export declare const enum ReactiveFlags {
     IS_SHALLOW = "__v_isShallow",
     RAW = "__v_raw"
 }
+
 export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
 /**
  * Returns a reactive proxy of the object.
@@ -220,18 +232,6 @@ type CollectionTypes = IterableCollections | WeakCollections;
 type IterableCollections = Map<any, any> | Set<any>;
 type WeakCollections = WeakMap<any, any> | WeakSet<any>;
 
-export declare const enum TrackOpTypes {
-    GET = "get",
-    HAS = "has",
-    ITERATE = "iterate"
-}
-export declare const enum TriggerOpTypes {
-    SET = "set",
-    ADD = "add",
-    DELETE = "delete",
-    CLEAR = "clear"
-}
-
 export declare class EffectScope {
     detached: boolean;
     constructor(detached?: boolean);
@@ -276,18 +276,19 @@ export type DebuggerEventExtraInfo = {
     oldValue?: any;
     oldTarget?: Map<any, any> | Set<any>;
 };
-export declare const ITERATE_KEY: unique symbol;
 export declare class ReactiveEffect<T = any> {
     fn: () => T;
-    scheduler: EffectScheduler | null;
+    trigger: () => void;
+    scheduler?: EffectScheduler | undefined;
     active: boolean;
     deps: Dep[];
-    parent: ReactiveEffect | undefined;
     onStop?: () => void;
     onTrack?: (event: DebuggerEvent) => void;
     onTrigger?: (event: DebuggerEvent) => void;
-    constructor(fn: () => T, scheduler?: EffectScheduler | null, scope?: EffectScope);
-    run(): T | undefined;
+    constructor(fn: () => T, trigger: () => void, scheduler?: EffectScheduler | undefined, scope?: EffectScope);
+    get dirty(): boolean;
+    set dirty(v: boolean);
+    run(): T;
     stop(): void;
 }
 export interface DebuggerOptions {
@@ -334,42 +335,76 @@ export declare function enableTracking(): void;
  * Resets the previous global effect tracking state.
  */
 export declare function resetTracking(): void;
+export declare function pauseScheduling(): void;
+export declare function resetScheduling(): void;
+
+declare const ComputedRefSymbol: unique symbol;
+export interface ComputedRef<T = any> extends WritableComputedRef<T> {
+    readonly value: T;
+    [ComputedRefSymbol]: true;
+}
+export interface WritableComputedRef<T> extends Ref<T> {
+    readonly effect: ReactiveEffect<T>;
+}
+export type ComputedGetter<T> = (...args: any[]) => T;
+export type ComputedSetter<T> = (v: T) => void;
+export interface WritableComputedOptions<T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+}
+declare class ComputedRefImpl<T> {
+    private readonly _setter;
+    dep?: Dep;
+    private _value;
+    readonly effect: ReactiveEffect<T>;
+    readonly __v_isRef = true;
+    readonly [ReactiveFlags.IS_READONLY]: boolean;
+    _cacheable: boolean;
+    constructor(getter: ComputedGetter<T>, _setter: ComputedSetter<T>, isReadonly: boolean, isSSR: boolean);
+    get value(): T;
+    set value(newValue: T);
+    get _dirty(): boolean;
+    set _dirty(v: boolean);
+}
 /**
- * Tracks access to a reactive property.
+ * 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.
  *
- * This will check which effect is running at the moment and record it as dep
- * which records all effects that depend on the reactive property.
+ * @example
+ * ```js
+ * // Creating a readonly computed ref:
+ * const count = ref(1)
+ * const plusOne = computed(() => count.value + 1)
  *
- * @param target - Object holding the reactive property.
- * @param type - Defines the type of access to the reactive property.
- * @param key - Identifier of the reactive property to track.
- */
-export declare function track(target: object, type: TrackOpTypes, key: unknown): void;
-/**
- * Finds all deps associated with the target (or a specific property) and
- * triggers the effects stored within.
+ * console.log(plusOne.value) // 2
+ * plusOne.value++ // error
+ * ```
  *
- * @param target - The reactive object.
- * @param type - Defines the type of the operation that needs to trigger effects.
- * @param key - Can be used to target a specific reactive property in the target object.
+ * ```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 trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;
+export declare function computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
+export declare function computed<T>(options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions): WritableComputedRef<T>;
 
-type Dep = Set<ReactiveEffect> & TrackedMarkers;
-/**
- * wasTracked and newTracked maintain the status for several levels of effect
- * tracking recursion. One bit per level is used to define whether the dependency
- * was/is tracked.
- */
-type TrackedMarkers = {
-    /**
-     * wasTracked
-     */
-    w: number;
-    /**
-     * newTracked
-     */
-    n: number;
+type Dep = Map<ReactiveEffect, number> & {
+    cleanup: () => void;
+    computed?: ComputedRefImpl<any>;
 };
 
 declare const RefSymbol: unique symbol;
@@ -598,55 +633,30 @@ type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseTypes | Ref
     [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
 } : T;
 
-declare const ComputedRefSymbol: unique symbol;
-export interface ComputedRef<T = any> extends WritableComputedRef<T> {
-    readonly value: T;
-    [ComputedRefSymbol]: true;
-}
-export interface WritableComputedRef<T> extends Ref<T> {
-    readonly effect: ReactiveEffect<T>;
-}
-export type ComputedGetter<T> = (...args: any[]) => T;
-export type ComputedSetter<T> = (v: T) => void;
-export interface WritableComputedOptions<T> {
-    get: ComputedGetter<T>;
-    set: ComputedSetter<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
- * ```
+ * @deprecated use `computed` instead. See #5912
+ */
+export declare const deferredComputed: typeof computed;
+
+export declare const ITERATE_KEY: unique symbol;
+/**
+ * Tracks access to a reactive property.
  *
- * ```js
- * // Creating a writable computed ref:
- * const count = ref(1)
- * const plusOne = computed({
- *   get: () => count.value + 1,
- *   set: (val) => {
- *     count.value = val - 1
- *   }
- * })
+ * This will check which effect is running at the moment and record it as dep
+ * which records all effects that depend on the reactive property.
  *
- * plusOne.value = 1
- * console.log(count.value) // 0
- * ```
+ * @param target - Object holding the reactive property.
+ * @param type - Defines the type of access to the reactive property.
+ * @param key - Identifier of the reactive property to track.
+ */
+export declare function track(target: object, type: TrackOpTypes, key: unknown): void;
+/**
+ * Finds all deps associated with the target (or a specific property) and
+ * triggers the effects stored within.
  *
- * @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}
+ * @param target - The reactive object.
+ * @param type - Defines the type of the operation that needs to trigger effects.
+ * @param key - Can be used to target a specific reactive property in the target object.
  */
-export declare function computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
-export declare function computed<T>(options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions): WritableComputedRef<T>;
-
-export declare function deferredComputed<T>(getter: () => T): ComputedRef<T>;
+export declare function trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;