@vue/reactivity 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/reactivity.d.ts

@@ -1,6 +1,6 @@
 import { IfAny } from '@vue/shared';
 
-declare const enum ReactiveFlags {
+export declare const enum ReactiveFlags {
     SKIP = "__v_skip",
     IS_REACTIVE = "__v_isReactive",
     IS_READONLY = "__v_isReadonly",
@@ -30,7 +30,7 @@ export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
  * count.value // -> 1
  * ```
  */
-declare function reactive<T extends object>(target: T): UnwrapNestedRefs<T>;
+export declare function reactive<T extends object>(target: T): UnwrapNestedRefs<T>;
 declare const ShallowReactiveMarker: unique symbol;
 export type ShallowReactive<T> = T & {
     [ShallowReactiveMarker]?: true;
@@ -40,9 +40,9 @@ export type ShallowReactive<T> = T & {
  * level properties are reactive. It also does not auto-unwrap refs (even at the
  * root level).
  */
-declare function shallowReactive<T extends object>(target: T): ShallowReactive<T>;
-export type Primitive = string | number | boolean | bigint | symbol | undefined | null;
-export type Builtin = Primitive | Function | Date | Error | RegExp;
+export declare function shallowReactive<T extends object>(target: T): ShallowReactive<T>;
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type Builtin = Primitive | Function | Date | Error | RegExp;
 export type DeepReadonly<T> = T extends Builtin ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends WeakMap<infer K, infer V> ? WeakMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>> : T extends Promise<infer U> ? Promise<DeepReadonly<U>> : T extends Ref<infer U> ? Readonly<Ref<DeepReadonly<U>>> : T extends {} ? {
     readonly [K in keyof T]: DeepReadonly<T[K]>;
 } : Readonly<T>;
@@ -50,88 +50,58 @@ export type DeepReadonly<T> = T extends Builtin ? T : T extends Map<infer K, inf
  * Creates a readonly copy of the original object. Note the returned copy is not
  * made reactive, but `readonly` can be called on an already reactive object.
  */
-declare function readonly<T extends object>(target: T): DeepReadonly<UnwrapNestedRefs<T>>;
+export declare function readonly<T extends object>(target: T): DeepReadonly<UnwrapNestedRefs<T>>;
 /**
  * Returns a reactive-copy of the original object, where only the root level
  * properties are readonly, and does NOT unwrap refs nor recursively convert
  * returned properties.
  * This is used for creating the props proxy object for stateful components.
  */
-declare function shallowReadonly<T extends object>(target: T): Readonly<T>;
-declare function isReactive(value: unknown): boolean;
-declare function isReadonly(value: unknown): boolean;
-declare function isShallow(value: unknown): boolean;
-declare function isProxy(value: unknown): boolean;
-declare function toRaw<T>(observed: T): T;
+export declare function shallowReadonly<T extends object>(target: T): Readonly<T>;
+export declare function isReactive(value: unknown): boolean;
+export declare function isReadonly(value: unknown): boolean;
+export declare function isShallow(value: unknown): boolean;
+export declare function isProxy(value: unknown): boolean;
+export declare function toRaw<T>(observed: T): T;
 export type Raw<T> = T & {
     [RawSymbol]?: true;
 };
-declare function markRaw<T extends object>(value: T): Raw<T>;
+export declare function markRaw<T extends object>(value: T): Raw<T>;
 
-export type CollectionTypes = IterableCollections | WeakCollections;
-export type IterableCollections = Map<any, any> | Set<any>;
-export type WeakCollections = WeakMap<any, any> | WeakSet<any>;
+type CollectionTypes = IterableCollections | WeakCollections;
+type IterableCollections = Map<any, any> | Set<any>;
+type WeakCollections = WeakMap<any, any> | WeakSet<any>;
 
-declare const enum TrackOpTypes {
+export declare const enum TrackOpTypes {
     GET = "get",
     HAS = "has",
     ITERATE = "iterate"
 }
-declare const enum TriggerOpTypes {
+export declare const enum TriggerOpTypes {
     SET = "set",
     ADD = "add",
     DELETE = "delete",
     CLEAR = "clear"
 }
 
-declare class EffectScope {
+export declare class EffectScope {
     detached: boolean;
-    /**
-     * @internal
-     */
-    private _active;
-    /**
-     * @internal
-     */
-    effects: ReactiveEffect[];
-    /**
-     * @internal
-     */
-    cleanups: (() => void)[];
-    /**
-     * only assigned by undetached scope
-     * @internal
-     */
-    parent: EffectScope | undefined;
-    /**
-     * record undetached scopes
-     * @internal
-     */
-    scopes: EffectScope[] | undefined;
-    /**
-     * track a child scope's index in its parent's scopes array for optimized
-     * removal
-     * @internal
-     */
-    private index;
+    /* removed internal: _active */
+    /* removed internal: effects */
+    /* removed internal: cleanups */
+    /* removed internal: parent */
+    /* removed internal: scopes */
+    /* removed internal: index */
     constructor(detached?: boolean);
     get active(): boolean;
     run<T>(fn: () => T): T | undefined;
-    /**
-     * This should only be called on non-detached scopes
-     * @internal
-     */
-    on(): void;
-    /**
-     * This should only be called on non-detached scopes
-     * @internal
-     */
-    off(): void;
+    /* removed internal: on */
+    /* removed internal: off */
     stop(fromParent?: boolean): void;
 }
-declare function effectScope(detached?: boolean): EffectScope;
-declare function getCurrentScope(): EffectScope | undefined;
-declare function onScopeDispose(fn: () => void): void;
+export declare function effectScope(detached?: boolean): EffectScope;
+export declare function getCurrentScope(): EffectScope | undefined;
+export declare function onScopeDispose(fn: () => void): void;
 
 declare const ComputedRefSymbol: unique symbol;
 export interface ComputedRef<T = any> extends WritableComputedRef<T> {
@@ -160,8 +130,8 @@ declare class ComputedRefImpl<T> {
     get value(): T;
     set value(newValue: T);
 }
-declare function computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
-declare function computed<T>(options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions): WritableComputedRef<T>;
+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 EffectScheduler = (...args: any[]) => any;
 export type DebuggerEvent = {
@@ -175,26 +145,16 @@ export type DebuggerEventExtraInfo = {
     oldValue?: any;
     oldTarget?: Map<any, any> | Set<any>;
 };
-declare const ITERATE_KEY: unique symbol;
-declare class ReactiveEffect<T = any> {
+export declare const ITERATE_KEY: unique symbol;
+export declare class ReactiveEffect<T = any> {
     fn: () => T;
     scheduler: EffectScheduler | null;
     active: boolean;
     deps: Dep[];
     parent: ReactiveEffect | undefined;
-    /**
-     * Can be attached after creation
-     * @internal
-     */
-    computed?: ComputedRefImpl<T>;
-    /**
-     * @internal
-     */
-    allowRecurse?: boolean;
-    /**
-     * @internal
-     */
-    private deferStop?;
+    /* removed internal: computed */
+    /* removed internal: allowRecurse */
+    /* removed internal: deferStop */
     onStop?: () => void;
     onTrack?: (event: DebuggerEvent) => void;
     onTrigger?: (event: DebuggerEvent) => void;
@@ -217,21 +177,21 @@ export interface ReactiveEffectRunner<T = any> {
     (): T;
     effect: ReactiveEffect;
 }
-declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner;
-declare function stop(runner: ReactiveEffectRunner): void;
-declare function pauseTracking(): void;
-declare function enableTracking(): void;
-declare function resetTracking(): void;
-declare function track(target: object, type: TrackOpTypes, key: unknown): void;
-declare function trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;
+export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner;
+export declare function stop(runner: ReactiveEffectRunner): void;
+export declare function pauseTracking(): void;
+export declare function enableTracking(): void;
+export declare function resetTracking(): void;
+export declare function track(target: object, type: TrackOpTypes, key: unknown): void;
+export declare function trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;
 
-export type Dep = Set<ReactiveEffect> & TrackedMarkers;
+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.
  */
-export type TrackedMarkers = {
+type TrackedMarkers = {
     /**
      * wasTracked
      */
@@ -253,33 +213,33 @@ export interface Ref<T = any> {
      */
     [RefSymbol]: true;
 }
-declare function isRef<T>(r: Ref<T> | unknown): r is Ref<T>;
-declare function ref<T extends object>(value: T): [T] extends [Ref] ? T : Ref<UnwrapRef<T>>;
-declare function ref<T>(value: T): Ref<UnwrapRef<T>>;
-declare function ref<T = any>(): Ref<T | undefined>;
+export declare function isRef<T>(r: Ref<T> | unknown): r is Ref<T>;
+export declare function ref<T extends object>(value: T): [T] extends [Ref] ? T : Ref<UnwrapRef<T>>;
+export declare function ref<T>(value: T): Ref<UnwrapRef<T>>;
+export declare function ref<T = any>(): Ref<T | undefined>;
 declare const ShallowRefMarker: unique symbol;
 export type ShallowRef<T = any> = Ref<T> & {
     [ShallowRefMarker]?: true;
 };
-declare function shallowRef<T extends object>(value: T): T extends Ref ? T : ShallowRef<T>;
-declare function shallowRef<T>(value: T): ShallowRef<T>;
-declare function shallowRef<T = any>(): ShallowRef<T | undefined>;
-declare function triggerRef(ref: Ref): void;
-declare function unref<T>(ref: T | Ref<T>): T;
-declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
+export declare function shallowRef<T extends object>(value: T): T extends Ref ? T : ShallowRef<T>;
+export declare function shallowRef<T>(value: T): ShallowRef<T>;
+export declare function shallowRef<T = any>(): ShallowRef<T | undefined>;
+export declare function triggerRef(ref: Ref): void;
+export declare function unref<T>(ref: T | Ref<T>): T;
+export declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
 export type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
     get: () => T;
     set: (value: T) => void;
 };
-declare function customRef<T>(factory: CustomRefFactory<T>): Ref<T>;
+export declare function customRef<T>(factory: CustomRefFactory<T>): Ref<T>;
 export type ToRefs<T = any> = {
     [K in keyof T]: ToRef<T[K]>;
 };
-declare function toRefs<T extends object>(object: T): ToRefs<T>;
+export declare function toRefs<T extends object>(object: T): ToRefs<T>;
 export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>;
-declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
-declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
-export type BaseTypes = string | number | boolean;
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
+type BaseTypes = string | number | boolean;
 /**
  * This is a special exported interface for other packages to declare
  * additional types that should bail out for ref unwrapping. For example
@@ -299,7 +259,7 @@ export type ShallowUnwrapRef<T> = {
     [K in keyof T]: T[K] extends Ref<infer V> ? V : T[K] extends Ref<infer V> | undefined ? unknown extends V ? undefined : V | undefined : T[K];
 };
 export type UnwrapRef<T> = T extends ShallowRef<infer V> ? V : T extends Ref<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
-export type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
     [RawSymbol]?: true;
 } ? T : T extends ReadonlyArray<any> ? {
     [K in keyof T]: UnwrapRefSimple<T[K]>;
@@ -309,6 +269,5 @@ export type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseType
     [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
 } : T;
 
-declare function deferredComputed<T>(getter: () => T): ComputedRef<T>;
+export declare function deferredComputed<T>(getter: () => T): ComputedRef<T>;
 
-export { EffectScope, ITERATE_KEY, ReactiveEffect, ReactiveFlags, TrackOpTypes, TriggerOpTypes, computed, customRef, deferredComputed, effect, effectScope, enableTracking, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/reactivity",
-  "version": "3.3.0-alpha.4",
+  "version": "3.3.0-alpha.6",
   "description": "@vue/reactivity",
   "main": "index.js",
   "module": "dist/reactivity.esm-bundler.js",
@@ -36,6 +36,6 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/reactivity#readme",
   "dependencies": {
-    "@vue/shared": "3.3.0-alpha.4"
+    "@vue/shared": "3.3.0-alpha.6"
   }
 }