@reactive-vscode/reactivity 0.2.4 → 0.2.6-beta.1

package/dist/index.d.ts

@@ -1,8 +1,12 @@
-declare type Awaited_2<T> = T extends null | undefined ? T : T extends object & {
-    then(onfulfilled: infer F, ...args: infer _): any;
-} ? F extends (value: infer V, ...args: infer _) => any ? Awaited_2<V> : never : T;
+export declare const ARRAY_ITERATE_KEY: unique symbol;
 
-export declare type BaseTypes = string | number | boolean;
+export declare interface BaseComputedRef<T, S = T> extends Ref<T, S> {
+    [ComputedRefSymbol]: true;
+    /**
+     * @deprecated computed no longer uses effect
+     */
+    effect: ComputedRefImpl;
+}
 
 export declare type Builtin = Primitive | Function | Date | Error | RegExp;
 
@@ -41,33 +45,27 @@ export declare type Builtin = Primitive | Function | Date | Error | RegExp;
  */
 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 computed<T, S = T>(options: WritableComputedOptions<T, S>, debugOptions?: DebuggerOptions): WritableComputedRef<T, S>;
 
 export declare type ComputedGetter<T> = (oldValue?: T) => T;
 
-export declare interface ComputedRef<T = any> extends WritableComputedRef<T> {
+export declare interface ComputedRef<T = any> extends BaseComputedRef<T> {
     readonly value: T;
-    [ComputedRefSymbol]: true;
 }
 
-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);
+/**
+ * @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);
-    get _dirty(): boolean;
-    set _dirty(v: boolean);
 }
 
 export declare const ComputedRefSymbol: unique symbol;
@@ -89,7 +87,7 @@ export declare type CustomRefFactory<T> = (track: () => void, trigger: () => voi
 };
 
 export declare type DebuggerEvent = {
-    effect: ReactiveEffect;
+    effect: Subscriber;
 } & DebuggerEventExtraInfo;
 
 export declare type DebuggerEventExtraInfo = {
@@ -110,36 +108,35 @@ export declare type DeepReadonly<T> = T extends Builtin ? T : T extends Map<infe
     readonly [K in keyof T]: DeepReadonly<T[K]>;
 } : Readonly<T>;
 
-/**
- * @deprecated use `computed` instead. See #5912
- */
-export declare const deferredComputed: typeof computed;
-
-export declare type Dep = Map<ReactiveEffect, number> & {
-    cleanup: () => void;
-    computed?: ComputedRefImpl<any>;
-};
+export declare type DistributeRef<T> = T extends Ref<infer V> ? V : T;
 
-export declare type DistrubuteRef<T> = T extends Ref<infer V> ? V : T;
+export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner<T>;
 
-/**
- * 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;
+export declare enum EffectFlags {
+    /**
+     * ReactiveEffect only
+     */
+    ACTIVE = 1,
+    RUNNING = 2,
+    TRACKING = 4,
+    NOTIFIED = 8,
+    DIRTY = 16,
+    ALLOW_RECURSE = 32,
+    PAUSED = 64
+}
 
 export declare type EffectScheduler = (...args: any[]) => any;
 
 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;
     stop(fromParent?: boolean): void;
 }
@@ -167,6 +164,11 @@ export declare function enableTracking(): void;
  */
 export declare function getCurrentScope(): EffectScope | undefined;
 
+/**
+ * Returns the current active effect if there is one.
+ */
+export declare function getCurrentWatcher(): ReactiveEffect<any> | undefined;
+
 declare type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
 
 /**
@@ -223,8 +225,10 @@ export declare function isShallow(value: unknown): boolean;
 
 export declare const ITERATE_KEY: unique symbol;
 
+export declare const MAP_KEY_ITERATE_KEY: unique symbol;
+
 declare type MapSources<T, Immediate> = {
-    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : T[K] extends object ? Immediate extends true ? T[K] | undefined : T[K] : never;
+    [K in keyof T]: T[K] extends WatchSource<infer V> ? MaybeUndefined<V, Immediate> : T[K] extends object ? MaybeUndefined<T[K], Immediate> : never;
 };
 
 /**
@@ -251,15 +255,31 @@ declare type MapSources<T, Immediate> = {
  */
 export declare function markRaw<T extends object>(value: T): Raw<T>;
 
-export declare type MaybeRef<T = any> = T | Ref<T>;
+export declare type MaybeRef<T = any> = T | Ref<T> | ShallowRef<T> | WritableComputedRef<T>;
 
-export declare type MaybeRefOrGetter<T = any> = MaybeRef<T> | (() => T);
+export declare type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T);
+
+declare type MaybeUndefined<T, I> = I extends true ? T | undefined : T;
 
 declare type MultiWatchSources = (WatchSource<unknown> | object)[];
 
-export declare function nextTick<T = void, R = void>(this: T, fn?: (this: T) => R): Promise<Awaited_2<R>>;
+export declare function nextTick<T = void, R = void>(this: T, fn?: (this: T) => R): Promise<Awaited<R>>;
+
+export declare type OnCleanup = (cleanupFn: () => void) => void;
 
-declare type OnCleanup = (cleanupFn: () => void) => 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;
 
 /**
  * Registers a dispose callback on the current active effect scope. The
@@ -268,9 +288,20 @@ declare type OnCleanup = (cleanupFn: () => void) => void;
  * @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 declare function onScopeDispose(fn: () => void, failSilently?: boolean): void;
 
-export declare function pauseScheduling(): void;
+/**
+ * Registers a cleanup callback on the current active effect. This
+ * registered cleanup callback will be invoked right before the
+ * associated effect re-runs.
+ *
+ * @param cleanupFn - The callback function to attach to the effect's cleanup.
+ * @param failSilently - if `true`, will not throw warning when called without
+ * an active effect.
+ * @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;
 
 /**
  * Temporarily pauses tracking.
@@ -280,11 +311,9 @@ export declare function pauseTracking(): void;
 export declare type Primitive = string | number | boolean | bigint | symbol | undefined | null;
 
 /**
- * Returns a reactive proxy for the given object.
- *
- * If the object already is reactive, it's returned as-is. If not, a new
- * reactive proxy is created. Direct child properties that are refs are properly
- * handled, as well.
+ * Returns a proxy for the given object that shallowly unwraps properties that
+ * are refs. If the object already is reactive, it's returned as-is. If not, a
+ * new reactive proxy is created.
  *
  * @param objectWithRefs - Either an already-reactive object or a simple object
  * that contains refs.
@@ -297,6 +326,8 @@ export declare type Raw<T> = T & {
 
 export declare const RawSymbol: unique symbol;
 
+export declare type Reactive<T> = UnwrapNestedRefs<T> & (T extends readonly any[] ? ReactiveMarker : {});
+
 /**
  * Returns a reactive proxy of the object.
  *
@@ -312,28 +343,25 @@ export declare const RawSymbol: unique symbol;
  * @param target - The source object.
  * @see {@link https://vuejs.org/api/reactivity-core.html#reactive}
  */
-export declare function reactive<T extends object>(target: T): UnwrapNestedRefs<T>;
+export declare function reactive<T extends object>(target: T): Reactive<T>;
 
-export declare class ReactiveEffect<T = any> {
+export declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
     fn: () => T;
-    trigger: () => void;
-    scheduler?: EffectScheduler | undefined;
-    active: boolean;
-    deps: Dep[];
+    scheduler?: EffectScheduler;
     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);
+    constructor(fn: () => T);
+    pause(): void;
+    resume(): void;
     run(): T;
     stop(): void;
+    trigger(): void;
+    get dirty(): boolean;
 }
 
 export declare interface ReactiveEffectOptions extends DebuggerOptions {
-    lazy?: boolean;
     scheduler?: EffectScheduler;
-    scope?: EffectScope;
     allowRecurse?: boolean;
     onStop?: () => void;
 }
@@ -343,14 +371,33 @@ export declare interface ReactiveEffectRunner<T = any> {
     effect: ReactiveEffect;
 }
 
+export declare interface ReactiveEffectRunner<T = any> {
+    (): T;
+    effect: ReactiveEffect;
+}
+
 export declare enum ReactiveFlags {
     SKIP = "__v_skip",
     IS_REACTIVE = "__v_isReactive",
     IS_READONLY = "__v_isReadonly",
     IS_SHALLOW = "__v_isShallow",
-    RAW = "__v_raw"
+    RAW = "__v_raw",
+    IS_REF = "__v_isRef"
+}
+
+export declare interface ReactiveMarker {
+    [ReactiveMarkerSymbol]?: void;
 }
 
+export declare const ReactiveMarkerSymbol: unique symbol;
+
+/**
+ * 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[];
+
 /**
  * Takes an object (reactive or plain) or a ref and returns a readonly proxy to
  * the original.
@@ -382,8 +429,9 @@ export declare enum ReactiveFlags {
  */
 export declare function readonly<T extends object>(target: T): DeepReadonly<UnwrapNestedRefs<T>>;
 
-export declare interface Ref<T = any> {
-    value: T;
+export declare interface Ref<T = any, S = T> {
+    get value(): T;
+    set value(_: S);
     /**
      * Type differentiator only.
      * We need this to be in public d.ts but don't want it to show up in IDE
@@ -399,7 +447,7 @@ export declare interface Ref<T = any> {
  * @param value - The object to wrap in the ref.
  * @see {@link https://vuejs.org/api/reactivity-core.html#ref}
  */
-export declare function ref<T>(value: T): Ref<UnwrapRef<T>>;
+export declare function ref<T>(value: T): [T] extends [Ref] ? IfAny<T, Ref<T>, T> : Ref<UnwrapRef<T>, UnwrapRef<T> | T>;
 
 export declare function ref<T = any>(): Ref<T | undefined>;
 
@@ -421,8 +469,6 @@ export declare const RefSymbol: unique symbol;
 export declare interface RefUnwrapBailTypes {
 }
 
-export declare function resetScheduling(): void;
-
 /**
  * Resets the previous global effect tracking state.
  */
@@ -466,6 +512,11 @@ export declare function shallowReactive<T extends object>(target: T): ShallowRea
 
 export declare const ShallowReactiveMarker: unique symbol;
 
+/**
+ * Track array iteration and return raw array
+ */
+export declare function shallowReadArray<T>(arr: T[]): T[];
+
 /**
  * Shallow version of {@link readonly()}.
  *
@@ -498,7 +549,7 @@ export declare const ShallowReactiveMarker: unique symbol;
  */
 export declare function shallowReadonly<T extends object>(target: T): Readonly<T>;
 
-export declare type ShallowRef<T = any> = Ref<T> & {
+export declare type ShallowRef<T = any, S = T> = Ref<T, S> & {
     [ShallowRefMarker]?: true;
 };
 
@@ -526,7 +577,7 @@ export declare function shallowRef<T = any>(): ShallowRef<T | undefined>;
 export declare const ShallowRefMarker: unique symbol;
 
 export declare type ShallowUnwrapRef<T> = {
-    [K in keyof T]: DistrubuteRef<T[K]>;
+    [K in keyof T]: DistributeRef<T[K]>;
 };
 
 /**
@@ -536,6 +587,12 @@ export declare type ShallowUnwrapRef<T> = {
  */
 export declare function stop(runner: ReactiveEffectRunner): void;
 
+/**
+ * Subscriber is a type that tracks (or subscribes to) a list of deps.
+ */
+export declare interface Subscriber extends DebuggerOptions {
+}
+
 /**
  * Returns the raw, original object of a Vue-created proxy.
  *
@@ -561,6 +618,24 @@ export declare function stop(runner: ReactiveEffectRunner): void;
  */
 export declare function toRaw<T>(observed: T): 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 declare type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>;
 
 /**
@@ -642,7 +717,7 @@ export declare function toRefs<T extends object>(object: T): ToRefs<T>;
  * @param source - A getter, an existing ref, or a non-function value.
  * @see {@link https://vuejs.org/api/reactivity-utilities.html#tovalue}
  */
-export declare function toValue<T>(source: MaybeRefOrGetter<T> | ComputedRef<T>): T;
+export declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
 
 /**
  * Tracks access to a reactive property.
@@ -662,6 +737,8 @@ export declare enum TrackOpTypes {
     ITERATE = "iterate"
 }
 
+export declare function traverse(value: unknown, depth?: number, seen?: Set<unknown>): unknown;
+
 /**
  * Finds all deps associated with the target (or a specific property) and
  * triggers the effects stored within.
@@ -726,9 +803,9 @@ export declare function unref<T>(ref: MaybeRef<T> | ComputedRef<T>): T;
 
 export declare type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
 
-export declare type UnwrapRef<T> = T extends ShallowRef<infer V> ? V : T extends Ref<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+export declare type UnwrapRef<T> = T extends ShallowRef<infer V, infer _> ? V : T extends Ref<infer V, infer _> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
 
-export declare type UnwrapRefSimple<T> = T extends Function | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+export declare type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
     [RawSymbol]?: true;
 } ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? {
     [K in keyof T]: UnwrapRefSimple<T[K]>;
@@ -738,43 +815,59 @@ export declare type UnwrapRefSimple<T> = T extends Function | BaseTypes | Ref |
     [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
 } : T;
 
-export declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
 
-export declare function watch<T extends MultiWatchSources, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watch<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(sources: readonly [...T] | T, cb: [T] extends [ReactiveMarker] ? WatchCallback<T, MaybeUndefined<T, Immediate>> : WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
 
-export declare function watch<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watch<T extends MultiWatchSources, Immediate extends Readonly<boolean> = false>(sources: [...T], cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
 
-export declare function watch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
+export declare function watch<T extends object, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: WatchOptions<Immediate>): WatchHandle;
 
 export declare type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
 
 export declare type WatchEffect = (onCleanup: OnCleanup) => void;
 
-export declare function watchEffect(effect: WatchEffect, options?: WatchOptionsBase): WatchStopHandle;
+export declare function watchEffect(effect: WatchEffect, options?: WatchEffectOptions): WatchHandle;
+
+declare interface WatchEffectOptions extends DebuggerOptions {
+    flush?: 'pre' | 'sync';
+}
+
+export declare enum WatchErrorCodes {
+    WATCH_GETTER = 2,
+    WATCH_CALLBACK = 3,
+    WATCH_CLEANUP = 4
+}
+
+export declare interface WatchHandle extends WatchStopHandle {
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+}
 
-export declare interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
+export declare interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
     immediate?: Immediate;
-    deep?: boolean;
+    deep?: boolean | number;
     once?: boolean;
 }
 
-export declare interface WatchOptionsBase extends DebuggerOptions {
-    flush?: 'pre' | 'post' | 'sync';
-}
+export declare type WatchScheduler = (job: () => void, isFirstRun: boolean) => void;
 
-export declare type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T);
+export declare type WatchSource<T = any> = Ref<T, any> | ComputedRef<T> | (() => T);
 
 export declare type WatchStopHandle = () => void;
 
-export declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchStopHandle;
+export declare function watchSyncEffect(effect: WatchEffect, options?: DebuggerOptions): WatchHandle;
 
-export declare interface WritableComputedOptions<T> {
+export declare interface WritableComputedOptions<T, S = T> {
     get: ComputedGetter<T>;
-    set: ComputedSetter<T>;
+    set: ComputedSetter<S>;
 }
 
-export declare interface WritableComputedRef<T> extends Ref<T> {
-    readonly effect: ReactiveEffect<T>;
+export declare interface WritableComputedRef<T, S = T> extends BaseComputedRef<T, S> {
+    [WritableComputedRefSymbol]: true;
 }
 
+export declare const WritableComputedRefSymbol: unique symbol;
+
 export { }