@vue/reactivity 3.4.26 → 3.5.0-alpha.2

package/dist/reactivity.d.ts

@@ -19,186 +19,6 @@ export declare enum ReactiveFlags {
     RAW = "__v_raw"
 }
 
-type Dep = Map<ReactiveEffect, number> & {
-    cleanup: () => void;
-    computed?: ComputedRefImpl<any>;
-};
-
-export declare class EffectScope {
-    detached: boolean;
-    constructor(detached?: boolean);
-    get active(): boolean;
-    run<T>(fn: () => T): T | 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): void;
-
-export type EffectScheduler = (...args: any[]) => any;
-export type DebuggerEvent = {
-    effect: ReactiveEffect;
-} & DebuggerEventExtraInfo;
-export type DebuggerEventExtraInfo = {
-    target: object;
-    type: TrackOpTypes | TriggerOpTypes;
-    key: any;
-    newValue?: any;
-    oldValue?: any;
-    oldTarget?: Map<any, any> | Set<any>;
-};
-export declare class ReactiveEffect<T = any> {
-    fn: () => T;
-    trigger: () => void;
-    scheduler?: EffectScheduler | undefined;
-    active: boolean;
-    deps: Dep[];
-    onStop?: () => void;
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-    constructor(fn: () => T, trigger: () => void, scheduler?: EffectScheduler | undefined, scope?: EffectScope);
-    get dirty(): boolean;
-    set dirty(v: boolean);
-    run(): T;
-    stop(): void;
-}
-export interface DebuggerOptions {
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-}
-export interface ReactiveEffectOptions extends DebuggerOptions {
-    lazy?: boolean;
-    scheduler?: EffectScheduler;
-    scope?: EffectScope;
-    allowRecurse?: boolean;
-    onStop?: () => void;
-}
-export interface ReactiveEffectRunner<T = any> {
-    (): T;
-    effect: ReactiveEffect;
-}
-/**
- * Registers the given function to track reactive updates.
- *
- * The given function will be run once immediately. Every time any reactive
- * property that's accessed within it gets updated, the function will run again.
- *
- * @param fn - The function that will track reactive updates.
- * @param options - Allows to control the effect's behaviour.
- * @returns A runner that can be used to control the effect after creation.
- */
-export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner;
-/**
- * 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;
-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> = (oldValue?: T) => T;
-export type ComputedSetter<T> = (newValue: T) => void;
-export interface WritableComputedOptions<T> {
-    get: ComputedGetter<T>;
-    set: ComputedSetter<T>;
-}
-export declare class ComputedRefImpl<T> {
-    private getter;
-    private readonly _setter;
-    dep?: Dep;
-    private _value;
-    readonly effect: ReactiveEffect<T>;
-    readonly __v_isRef = true;
-    readonly [ReactiveFlags.IS_READONLY]: boolean;
-    _cacheable: boolean;
-    /**
-     * Dev only
-     */
-    _warnRecursive?: 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);
-}
-/**
- * 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>(options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions): WritableComputedRef<T>;
-
 export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
 /**
  * Returns a reactive proxy of the object.
@@ -407,6 +227,177 @@ export type Raw<T> = T & {
  * @see {@link https://vuejs.org/api/reactivity-advanced.html#markraw}
  */
 export declare function markRaw<T extends object>(value: T): Raw<T>;
+/**
+ * Returns a reactive proxy of the given value (if possible).
+ *
+ * If the given value is not an object, the original value itself is returned.
+ *
+ * @param value - The value for which a reactive proxy shall be created.
+ */
+export declare const toReactive: <T extends unknown>(value: T) => T;
+/**
+ * Returns a readonly proxy of the given value (if possible).
+ *
+ * If the given value is not an object, the original value itself is returned.
+ *
+ * @param value - The value for which a readonly proxy shall be created.
+ */
+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 {
+    ACTIVE = 1,
+    RUNNING = 2,
+    TRACKING = 4,
+    NOTIFIED = 8,
+    DIRTY = 16,
+    ALLOW_RECURSE = 32,
+    NO_BATCH = 64
+}
+/**
+ * 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);
+    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 iff there is no currenct 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;
+export interface ComputedRef<T = any> extends WritableComputedRef<T> {
+    readonly value: T;
+    [ComputedRefSymbol]: true;
+}
+export interface WritableComputedRef<T> extends Ref<T> {
+    /**
+     * @deprecated computed no longer uses effect
+     */
+    effect: ComputedRefImpl;
+}
+export type ComputedGetter<T> = (oldValue?: T) => T;
+export type ComputedSetter<T> = (newValue: T) => void;
+export interface WritableComputedOptions<T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+}
+/**
+ * @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(): any;
+    set value(newValue: any);
+}
+/**
+ * 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>(options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions): WritableComputedRef<T>;
 
 declare const RefSymbol: unique symbol;
 declare const RawSymbol: unique symbol;
@@ -633,12 +624,9 @@ type UnwrapRefSimple<T> = T extends Function | BaseTypes | Ref | RefUnwrapBailTy
     [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
 } : T;
 
-/**
- * @deprecated use `computed` instead. See #5912
- */
-export declare const deferredComputed: typeof computed;
-
 export declare const ITERATE_KEY: unique symbol;
+export declare const MAP_KEY_ITERATE_KEY: unique symbol;
+export declare const ARRAY_ITERATE_KEY: unique symbol;
 /**
  * Tracks access to a reactive property.
  *
@@ -660,3 +648,46 @@ 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;
+    constructor(detached?: boolean);
+    get active(): boolean;
+    run<T>(fn: () => T): T | 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
+ * - if input is non-reactive or shallowReactive: the original raw array
+ */
+export declare function reactiveReadArray<T>(array: T[]): T[];
+/**
+ * Track array iteration and return raw array
+ */
+export declare function shallowReadArray<T>(arr: T[]): T[];
+