🎩 You're Invited:Meet the Socket team at Black Hat in Las Vegas, August 3-6.RSVP →
Sign In

@atom-vue/reactivity

Package Overview
Dependencies
Maintainers
3
Versions
89
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@atom-vue/reactivity - npm Package Compare versions

Comparing version
3.0.1-alpha.1
 to
3.0.1-beta.0
+306
-207
dist/reactivity.cjs.js

@@ -36,5 +36,5 @@ 'use strict';

function createReactiveEffect(fn, options) {
const effect = function reactiveEffect(...args) {
const effect = function reactiveEffect() {
if (!effect.active) {
return options.scheduler ? undefined : fn(...args);
return options.scheduler ? undefined : fn();
}

@@ -47,3 +47,3 @@ if (!effectStack.includes(effect)) {

activeEffect = effect;
return fn(...args);
return fn();
}

@@ -120,13 +120,7 @@ finally {

const effects = new Set();
const computedRunners = new Set();
const add = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach(effect => {
if (effect !== activeEffect || !shouldTrack) {
if (effect.options.computed) {
computedRunners.add(effect);
}
else {
effects.add(effect);
}
if (effect !== activeEffect || effect.options.allowRecurse) {
effects.add(effect);
}

@@ -154,11 +148,29 @@ });

// also run for iteration key on ADD | DELETE | Map.SET
const isAddOrDelete = type === "add" /* ADD */ ||
(type === "delete" /* DELETE */ && !shared.isArray(target));
if (isAddOrDelete ||
(type === "set" /* SET */ && target instanceof Map)) {
add(depsMap.get(shared.isArray(target) ? 'length' : ITERATE_KEY));
switch (type) {
case "add" /* ADD */:
if (!shared.isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (shared.isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
else if (shared.isIntegerKey(key)) {
// new index added to array -> length changes
add(depsMap.get('length'));
}
break;
case "delete" /* DELETE */:
if (!shared.isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (shared.isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set" /* SET */:
if (shared.isMap(target)) {
add(depsMap.get(ITERATE_KEY));
}
break;
}
if (isAddOrDelete && target instanceof Map) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}

@@ -184,5 +196,2 @@ const run = (effect) => {

};
// Important: computed effects must be run first so that computed getters
// can be invalidated before any normal effects that depend on them are run.
computedRunners.forEach(run);
effects.forEach(run);

@@ -200,2 +209,3 @@ }

['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {

@@ -207,6 +217,6 @@ const arr = toRaw(this);

// we run the method using the original args first (which may be reactive)
const res = arr[key](...args);
const res = method.apply(arr, args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return arr[key](...args.map(toRaw));
return method.apply(arr, args.map(toRaw));
}

@@ -218,11 +228,21 @@ else {

});
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {
pauseTracking();
const res = method.apply(this, args);
enableTracking();
return res;
};
});
function createGetter(isReadonly = false, shallow = false) {
return function get(target, key, receiver) {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */ || key === '__proto__') {
else if (key === "__v_raw" /* RAW */ &&
receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
return target;

@@ -235,27 +255,26 @@ }

const res = Reflect.get(target, key, receiver);
if (shared.isSymbol(key) && builtInSymbols.has(key)) {
const keyIsSymbol = shared.isSymbol(key);
if (keyIsSymbol
? builtInSymbols.has(key)
: key === `__proto__` || key === `__v_isRef`) {
return res;
}
if (!isReadonly) {
track(target, "get" /* GET */, key);
}
if (shallow) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
if (isRef(res)) {
if (targetIsArray) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
else {
// ref unwrapping, only for Objects, not for Arrays.
return res.value;
}
// ref unwrapping - does not apply for Array + integer key.
const shouldUnwrap = !targetIsArray || !shared.isIntegerKey(key);
return shouldUnwrap ? res.value : res;
}
!isReadonly && track(target, "get" /* GET */, key);
return shared.isObject(res)
? isReadonly
? // need to lazy access readonly and reactive here to avoid
// circular dependency
readonly(res)
: reactive(res)
: res;
if (shared.isObject(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};

@@ -275,3 +294,5 @@ }

}
const hadKey = shared.hasOwn(target, key);
const hadKey = shared.isArray(target) && shared.isIntegerKey(key)
? Number(key) < target.length
: shared.hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);

@@ -301,3 +322,5 @@ // don't trigger if target is something up in the prototype chain of original

const result = Reflect.has(target, key);
track(target, "has" /* HAS */, key);
if (!shared.isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has" /* HAS */, key);
}
return result;

@@ -318,4 +341,2 @@ }

get: readonlyGet,
has,
ownKeys,
set(target, key) {

@@ -334,47 +355,52 @@ {

};
const shallowReactiveHandlers = {
...mutableHandlers,
const shallowReactiveHandlers = shared.extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
};
});
// Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
const shallowReadonlyHandlers = {
...readonlyHandlers,
const shallowReadonlyHandlers = shared.extend({}, readonlyHandlers, {
get: shallowReadonlyGet
};
});
const toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
const toReadonly = (value) => shared.isObject(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, wrap) {
target = toRaw(target);
function get$1(target, key, isReadonly = false, isShallow = false) {
// #1772: readonly(reactive(Map)) should return readonly + reactive version
// of the value
target = target["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "get" /* GET */, key);
!isReadonly && track(rawTarget, "get" /* GET */, key);
}
track(target, "get" /* GET */, rawKey);
const { has, get } = getProto(target);
if (has.call(target, key)) {
return wrap(get.call(target, key));
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
const { has } = getProto(rawTarget);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
}
else if (has.call(target, rawKey)) {
return wrap(get.call(target, rawKey));
else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1(key) {
const target = toRaw(this);
function has$1(key, isReadonly = false) {
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "has" /* HAS */, key);
!isReadonly && track(rawTarget, "has" /* HAS */, key);
}
track(target, "has" /* HAS */, rawKey);
const has = getProto(target).has;
return has.call(target, key) || has.call(target, rawKey);
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
return key === rawKey
? target.has(key)
: target.has(key) || target.has(rawKey);
}
function size(target) {
target = toRaw(target);
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(getProto(target), 'size', target);
function size(target, isReadonly = false) {
target = target["__v_raw" /* RAW */];
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(target, 'size', target);
}

@@ -386,3 +412,3 @@ function add(value) {

const hadKey = proto.has.call(target, value);
const result = proto.add.call(target, value);
const result = target.add(value);
if (!hadKey) {

@@ -396,3 +422,3 @@ trigger(target, "add" /* ADD */, value, value);

const target = toRaw(this);
const { has, get, set } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -407,3 +433,3 @@ if (!hadKey) {

const oldValue = get.call(target, key);
const result = set.call(target, key, value);
const result = target.set(key, value);
if (!hadKey) {

@@ -419,3 +445,3 @@ trigger(target, "add" /* ADD */, key, value);

const target = toRaw(this);
const { has, get, delete: del } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -431,3 +457,3 @@ if (!hadKey) {

// forward the operation before queueing reactions
const result = del.call(target, key);
const result = target.delete(key);
if (hadKey) {

@@ -441,3 +467,3 @@ trigger(target, "delete" /* DELETE */, key, undefined, oldValue);

const hadItems = target.size !== 0;
const oldTarget = target instanceof Map
const oldTarget = shared.isMap(target)
? new Map(target)

@@ -447,3 +473,3 @@ : new Set(target)

// forward the operation before queueing reactions
const result = getProto(target).clear.call(target);
const result = target.clear();
if (hadItems) {

@@ -454,27 +480,28 @@ trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);

}
function createForEach(isReadonly) {
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = toRaw(observed);
const wrap = isReadonly ? toReadonly : toReactive;
!isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY);
// important: create sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
function wrappedCallback(value, key) {
return callback.call(observed, wrap(value), wrap(key), observed);
}
return getProto(target).forEach.call(target, wrappedCallback, thisArg);
const target = observed["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
return target.forEach((value, key) => {
// important: make sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly) {
function createIterableMethod(method, isReadonly, isShallow) {
return function (...args) {
const target = toRaw(this);
const isMap = target instanceof Map;
const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
const isKeyOnly = method === 'keys' && isMap;
const innerIterator = getProto(target)[method].apply(target, args);
const wrap = isReadonly ? toReadonly : toReactive;
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const targetIsMap = shared.isMap(rawTarget);
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
const isKeyOnly = method === 'keys' && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly &&
track(target, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
// return a wrapped iterator which returns observed versions of the

@@ -511,3 +538,3 @@ // values emitted from the real iterator

get(key) {
return get$1(this, key, toReactive);
return get$1(this, key);
},

@@ -522,7 +549,7 @@ get size() {

clear,
forEach: createForEach(false)
forEach: createForEach(false, false)
};
const readonlyInstrumentations = {
const shallowInstrumentations = {
get(key) {
return get$1(this, key, toReadonly);
return get$1(this, key, false, true);
},

@@ -533,2 +560,18 @@ get size() {

has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add" /* ADD */),

@@ -538,21 +581,24 @@ set: createReadonlyMethod("set" /* SET */),

clear: createReadonlyMethod("clear" /* CLEAR */),
forEach: createForEach(true)
forEach: createForEach(true, false)
};
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
iteratorMethods.forEach(method => {
mutableInstrumentations[method] = createIterableMethod(method, false);
readonlyInstrumentations[method] = createIterableMethod(method, true);
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly) {
const instrumentations = isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow
? shallowInstrumentations
: isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */) {
else if (key === "__v_raw" /* RAW */) {
return target;

@@ -566,6 +612,9 @@ }

const mutableCollectionHandlers = {
get: createInstrumentationGetter(false)
get: createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true)
get: createInstrumentationGetter(true, false)
};

@@ -584,12 +633,26 @@ function checkIdentityKeys(target, has, key) {

const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);
const isObservableType = /*#__PURE__*/ shared.makeMap('Object,Array,Map,Set,WeakMap,WeakSet');
const canObserve = (value) => {
return (!value.__v_skip &&
isObservableType(shared.toRawType(value)) &&
!Object.isFrozen(value));
};
const reactiveMap = new WeakMap();
const readonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case 'Object':
case 'Array':
return 1 /* COMMON */;
case 'Map':
case 'Set':
case 'WeakMap':
case 'WeakSet':
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
? 0 /* INVALID */
: targetTypeMap(shared.toRawType(value));
}
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target.__v_isReadonly) {
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
return target;

@@ -603,3 +666,3 @@ }

function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, mutableCollectionHandlers);
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
}

@@ -625,25 +688,29 @@ function readonly(target) {

// exception: calling readonly() on a reactive object
if (target.__v_raw && !(isReadonly && target.__v_isReactive)) {
if (target["__v_raw" /* RAW */] &&
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
return target;
}
// target already has corresponding Proxy
if (shared.hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) {
return isReadonly ? target.__v_readonly : target.__v_reactive;
const proxyMap = isReadonly ? readonlyMap : reactiveMap;
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
// only a whitelist of value types can be observed.
if (!canObserve(target)) {
const targetType = getTargetType(target);
if (targetType === 0 /* INVALID */) {
return target;
}
const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
shared.def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed);
return observed;
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value.__v_raw);
return isReactive(value["__v_raw" /* RAW */]);
}
return !!(value && value.__v_isReactive);
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
}
function isReadonly(value) {
return !!(value && value.__v_isReadonly);
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
}

@@ -654,6 +721,6 @@ function isProxy(value) {

function toRaw(observed) {
return (observed && toRaw(observed.__v_raw)) || observed;
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
}
function markRaw(value) {
shared.def(value, "__v_skip" /* skip */, true);
shared.def(value, "__v_skip" /* SKIP */, true);
return value;

@@ -664,3 +731,3 @@ }

function isRef(r) {
return r ? r.__v_isRef === true : false;
return Boolean(r && r.__v_isRef === true);
}

@@ -673,2 +740,21 @@ function ref(value) {

}
class RefImpl {
constructor(_rawValue, _shallow = false) {
this._rawValue = _rawValue;
this._shallow = _shallow;
this.__v_isRef = true;
this._value = _shallow ? _rawValue : convert(_rawValue);
}
get value() {
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newVal) {
if (shared.hasChanged(toRaw(newVal), this._rawValue)) {
this._rawValue = newVal;
this._value = this._shallow ? newVal : convert(newVal);
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
}
}
}
function createRef(rawValue, shallow = false) {

@@ -678,21 +764,6 @@ if (isRef(rawValue)) {

}
let value = shallow ? rawValue : convert(rawValue);
const r = {
__v_isRef: true,
get value() {
track(r, "get" /* GET */, 'value');
return value;
},
set value(newVal) {
if (shared.hasChanged(toRaw(newVal), rawValue)) {
rawValue = newVal;
value = shallow ? newVal : convert(newVal);
trigger(r, "set" /* SET */, 'value', { newValue: newVal } );
}
}
};
return r;
return new RefImpl(rawValue, shallow);
}
function triggerRef(ref) {
trigger(ref, "set" /* SET */, 'value', { newValue: ref.value } );
trigger(ref, "set" /* SET */, 'value', ref.value );
}

@@ -702,15 +773,37 @@ function unref(ref) {

}
function customRef(factory) {
const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value'));
const r = {
__v_isRef: true,
get value() {
return get();
},
set value(v) {
set(v);
const shallowUnwrapHandlers = {
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
};
return r;
else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs)
? objectWithRefs
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this.__v_isRef = true;
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
this._get = get;
this._set = set;
}
get value() {
return this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {

@@ -720,3 +813,3 @@ if ( !isProxy(object)) {

}
const ret = {};
const ret = shared.isArray(object) ? new Array(object.length) : {};
for (const key in object) {

@@ -727,14 +820,49 @@ ret[key] = toRef(object, key);

}
class ObjectRefImpl {
constructor(_object, _key) {
this._object = _object;
this._key = _key;
this.__v_isRef = true;
}
get value() {
return this._object[this._key];
}
set value(newVal) {
this._object[this._key] = newVal;
}
}
function toRef(object, key) {
return {
__v_isRef: true,
get value() {
return object[key];
},
set value(newVal) {
object[key] = newVal;
return isRef(object[key])
? object[key]
: new ObjectRefImpl(object, key);
}
class ComputedRefImpl {
constructor(getter, _setter, isReadonly) {
this._setter = _setter;
this._dirty = true;
this.__v_isRef = true;
this.effect = effect(getter, {
lazy: true,
scheduler: () => {
if (!this._dirty) {
this._dirty = true;
trigger(toRaw(this), "set" /* SET */, 'value');
}
}
});
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
}
get value() {
if (this._dirty) {
this._value = this.effect();
this._dirty = false;
}
};
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newValue) {
this._setter(newValue);
}
}
function computed(getterOrOptions) {

@@ -754,33 +882,3 @@ let getter;

}
let dirty = true;
let value;
let computed;
const runner = effect(getter, {
lazy: true,
// mark effect as computed so that it gets priority during trigger
computed: true,
scheduler: () => {
if (!dirty) {
dirty = true;
trigger(computed, "set" /* SET */, 'value');
}
}
});
computed = {
__v_isRef: true,
// expose effect so computed can be stopped
effect: runner,
get value() {
if (dirty) {
value = runner();
dirty = false;
}
track(computed, "get" /* GET */, 'value');
return value;
},
set value(newValue) {
setter(newValue);
}
};
return computed;
return new ComputedRefImpl(getter, setter, shared.isFunction(getterOrOptions) || !getterOrOptions.set);
}

@@ -799,2 +897,3 @@

exports.pauseTracking = pauseTracking;
exports.proxyRefs = proxyRefs;
exports.reactive = reactive;

@@ -801,0 +900,0 @@ exports.readonly = readonly;

+304
-205
dist/reactivity.cjs.prod.js

@@ -36,5 +36,5 @@ 'use strict';

function createReactiveEffect(fn, options) {
const effect = function reactiveEffect(...args) {
const effect = function reactiveEffect() {
if (!effect.active) {
return options.scheduler ? undefined : fn(...args);
return options.scheduler ? undefined : fn();
}

@@ -47,3 +47,3 @@ if (!effectStack.includes(effect)) {

activeEffect = effect;
return fn(...args);
return fn();
}

@@ -112,13 +112,7 @@ finally {

const effects = new Set();
const computedRunners = new Set();
const add = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach(effect => {
if (effect !== activeEffect || !shouldTrack) {
if (effect.options.computed) {
computedRunners.add(effect);
}
else {
effects.add(effect);
}
if (effect !== activeEffect || effect.options.allowRecurse) {
effects.add(effect);
}

@@ -146,11 +140,29 @@ });

// also run for iteration key on ADD | DELETE | Map.SET
const isAddOrDelete = type === "add" /* ADD */ ||
(type === "delete" /* DELETE */ && !shared.isArray(target));
if (isAddOrDelete ||
(type === "set" /* SET */ && target instanceof Map)) {
add(depsMap.get(shared.isArray(target) ? 'length' : ITERATE_KEY));
switch (type) {
case "add" /* ADD */:
if (!shared.isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (shared.isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
else if (shared.isIntegerKey(key)) {
// new index added to array -> length changes
add(depsMap.get('length'));
}
break;
case "delete" /* DELETE */:
if (!shared.isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (shared.isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set" /* SET */:
if (shared.isMap(target)) {
add(depsMap.get(ITERATE_KEY));
}
break;
}
if (isAddOrDelete && target instanceof Map) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}

@@ -165,5 +177,2 @@ const run = (effect) => {

};
// Important: computed effects must be run first so that computed getters
// can be invalidated before any normal effects that depend on them are run.
computedRunners.forEach(run);
effects.forEach(run);

@@ -181,2 +190,3 @@ }

['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {

@@ -188,6 +198,6 @@ const arr = toRaw(this);

// we run the method using the original args first (which may be reactive)
const res = arr[key](...args);
const res = method.apply(arr, args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return arr[key](...args.map(toRaw));
return method.apply(arr, args.map(toRaw));
}

@@ -199,11 +209,21 @@ else {

});
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {
pauseTracking();
const res = method.apply(this, args);
enableTracking();
return res;
};
});
function createGetter(isReadonly = false, shallow = false) {
return function get(target, key, receiver) {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */ || key === '__proto__') {
else if (key === "__v_raw" /* RAW */ &&
receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
return target;

@@ -216,27 +236,26 @@ }

const res = Reflect.get(target, key, receiver);
if (shared.isSymbol(key) && builtInSymbols.has(key)) {
const keyIsSymbol = shared.isSymbol(key);
if (keyIsSymbol
? builtInSymbols.has(key)
: key === `__proto__` || key === `__v_isRef`) {
return res;
}
if (!isReadonly) {
track(target, "get" /* GET */, key);
}
if (shallow) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
if (isRef(res)) {
if (targetIsArray) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
else {
// ref unwrapping, only for Objects, not for Arrays.
return res.value;
}
// ref unwrapping - does not apply for Array + integer key.
const shouldUnwrap = !targetIsArray || !shared.isIntegerKey(key);
return shouldUnwrap ? res.value : res;
}
!isReadonly && track(target, "get" /* GET */, key);
return shared.isObject(res)
? isReadonly
? // need to lazy access readonly and reactive here to avoid
// circular dependency
readonly(res)
: reactive(res)
: res;
if (shared.isObject(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};

@@ -256,3 +275,5 @@ }

}
const hadKey = shared.hasOwn(target, key);
const hadKey = shared.isArray(target) && shared.isIntegerKey(key)
? Number(key) < target.length
: shared.hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);

@@ -282,3 +303,5 @@ // don't trigger if target is something up in the prototype chain of original

const result = Reflect.has(target, key);
track(target, "has" /* HAS */, key);
if (!shared.isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has" /* HAS */, key);
}
return result;

@@ -299,4 +322,2 @@ }

get: readonlyGet,
has,
ownKeys,
set(target, key) {

@@ -309,47 +330,52 @@ return true;

};
const shallowReactiveHandlers = {
...mutableHandlers,
const shallowReactiveHandlers = shared.extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
};
});
// Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
const shallowReadonlyHandlers = {
...readonlyHandlers,
const shallowReadonlyHandlers = shared.extend({}, readonlyHandlers, {
get: shallowReadonlyGet
};
});
const toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
const toReadonly = (value) => shared.isObject(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, wrap) {
target = toRaw(target);
function get$1(target, key, isReadonly = false, isShallow = false) {
// #1772: readonly(reactive(Map)) should return readonly + reactive version
// of the value
target = target["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "get" /* GET */, key);
!isReadonly && track(rawTarget, "get" /* GET */, key);
}
track(target, "get" /* GET */, rawKey);
const { has, get } = getProto(target);
if (has.call(target, key)) {
return wrap(get.call(target, key));
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
const { has } = getProto(rawTarget);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
}
else if (has.call(target, rawKey)) {
return wrap(get.call(target, rawKey));
else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1(key) {
const target = toRaw(this);
function has$1(key, isReadonly = false) {
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "has" /* HAS */, key);
!isReadonly && track(rawTarget, "has" /* HAS */, key);
}
track(target, "has" /* HAS */, rawKey);
const has = getProto(target).has;
return has.call(target, key) || has.call(target, rawKey);
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
return key === rawKey
? target.has(key)
: target.has(key) || target.has(rawKey);
}
function size(target) {
target = toRaw(target);
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(getProto(target), 'size', target);
function size(target, isReadonly = false) {
target = target["__v_raw" /* RAW */];
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(target, 'size', target);
}

@@ -361,3 +387,3 @@ function add(value) {

const hadKey = proto.has.call(target, value);
const result = proto.add.call(target, value);
const result = target.add(value);
if (!hadKey) {

@@ -371,3 +397,3 @@ trigger(target, "add" /* ADD */, value, value);

const target = toRaw(this);
const { has, get, set } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -379,3 +405,3 @@ if (!hadKey) {

const oldValue = get.call(target, key);
const result = set.call(target, key, value);
const result = target.set(key, value);
if (!hadKey) {

@@ -391,3 +417,3 @@ trigger(target, "add" /* ADD */, key, value);

const target = toRaw(this);
const { has, get, delete: del } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -400,3 +426,3 @@ if (!hadKey) {

// forward the operation before queueing reactions
const result = del.call(target, key);
const result = target.delete(key);
if (hadKey) {

@@ -411,3 +437,3 @@ trigger(target, "delete" /* DELETE */, key, undefined);

// forward the operation before queueing reactions
const result = getProto(target).clear.call(target);
const result = target.clear();
if (hadItems) {

@@ -418,27 +444,28 @@ trigger(target, "clear" /* CLEAR */, undefined, undefined);

}
function createForEach(isReadonly) {
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = toRaw(observed);
const wrap = isReadonly ? toReadonly : toReactive;
!isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY);
// important: create sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
function wrappedCallback(value, key) {
return callback.call(observed, wrap(value), wrap(key), observed);
}
return getProto(target).forEach.call(target, wrappedCallback, thisArg);
const target = observed["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
return target.forEach((value, key) => {
// important: make sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly) {
function createIterableMethod(method, isReadonly, isShallow) {
return function (...args) {
const target = toRaw(this);
const isMap = target instanceof Map;
const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
const isKeyOnly = method === 'keys' && isMap;
const innerIterator = getProto(target)[method].apply(target, args);
const wrap = isReadonly ? toReadonly : toReactive;
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const targetIsMap = shared.isMap(rawTarget);
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
const isKeyOnly = method === 'keys' && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly &&
track(target, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
// return a wrapped iterator which returns observed versions of the

@@ -471,3 +498,3 @@ // values emitted from the real iterator

get(key) {
return get$1(this, key, toReactive);
return get$1(this, key);
},

@@ -482,7 +509,7 @@ get size() {

clear,
forEach: createForEach(false)
forEach: createForEach(false, false)
};
const readonlyInstrumentations = {
const shallowInstrumentations = {
get(key) {
return get$1(this, key, toReadonly);
return get$1(this, key, false, true);
},

@@ -493,2 +520,18 @@ get size() {

has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add" /* ADD */),

@@ -498,21 +541,24 @@ set: createReadonlyMethod("set" /* SET */),

clear: createReadonlyMethod("clear" /* CLEAR */),
forEach: createForEach(true)
forEach: createForEach(true, false)
};
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
iteratorMethods.forEach(method => {
mutableInstrumentations[method] = createIterableMethod(method, false);
readonlyInstrumentations[method] = createIterableMethod(method, true);
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly) {
const instrumentations = isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow
? shallowInstrumentations
: isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */) {
else if (key === "__v_raw" /* RAW */) {
return target;

@@ -526,18 +572,35 @@ }

const mutableCollectionHandlers = {
get: createInstrumentationGetter(false)
get: createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true)
get: createInstrumentationGetter(true, false)
};
const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);
const isObservableType = /*#__PURE__*/ shared.makeMap('Object,Array,Map,Set,WeakMap,WeakSet');
const canObserve = (value) => {
return (!value.__v_skip &&
isObservableType(shared.toRawType(value)) &&
!Object.isFrozen(value));
};
const reactiveMap = new WeakMap();
const readonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case 'Object':
case 'Array':
return 1 /* COMMON */;
case 'Map':
case 'Set':
case 'WeakMap':
case 'WeakSet':
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
? 0 /* INVALID */
: targetTypeMap(shared.toRawType(value));
}
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target.__v_isReadonly) {
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
return target;

@@ -551,3 +614,3 @@ }

function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, mutableCollectionHandlers);
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
}

@@ -570,25 +633,29 @@ function readonly(target) {

// exception: calling readonly() on a reactive object
if (target.__v_raw && !(isReadonly && target.__v_isReactive)) {
if (target["__v_raw" /* RAW */] &&
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
return target;
}
// target already has corresponding Proxy
if (shared.hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) {
return isReadonly ? target.__v_readonly : target.__v_reactive;
const proxyMap = isReadonly ? readonlyMap : reactiveMap;
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
// only a whitelist of value types can be observed.
if (!canObserve(target)) {
const targetType = getTargetType(target);
if (targetType === 0 /* INVALID */) {
return target;
}
const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
shared.def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed);
return observed;
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value.__v_raw);
return isReactive(value["__v_raw" /* RAW */]);
}
return !!(value && value.__v_isReactive);
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
}
function isReadonly(value) {
return !!(value && value.__v_isReadonly);
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
}

@@ -599,6 +666,6 @@ function isProxy(value) {

function toRaw(observed) {
return (observed && toRaw(observed.__v_raw)) || observed;
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
}
function markRaw(value) {
shared.def(value, "__v_skip" /* skip */, true);
shared.def(value, "__v_skip" /* SKIP */, true);
return value;

@@ -609,3 +676,3 @@ }

function isRef(r) {
return r ? r.__v_isRef === true : false;
return Boolean(r && r.__v_isRef === true);
}

@@ -618,2 +685,21 @@ function ref(value) {

}
class RefImpl {
constructor(_rawValue, _shallow = false) {
this._rawValue = _rawValue;
this._shallow = _shallow;
this.__v_isRef = true;
this._value = _shallow ? _rawValue : convert(_rawValue);
}
get value() {
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newVal) {
if (shared.hasChanged(toRaw(newVal), this._rawValue)) {
this._rawValue = newVal;
this._value = this._shallow ? newVal : convert(newVal);
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
}
}
}
function createRef(rawValue, shallow = false) {

@@ -623,18 +709,3 @@ if (isRef(rawValue)) {

}
let value = shallow ? rawValue : convert(rawValue);
const r = {
__v_isRef: true,
get value() {
track(r, "get" /* GET */, 'value');
return value;
},
set value(newVal) {
if (shared.hasChanged(toRaw(newVal), rawValue)) {
rawValue = newVal;
value = shallow ? newVal : convert(newVal);
trigger(r, "set" /* SET */, 'value', void 0);
}
}
};
return r;
return new RefImpl(rawValue, shallow);
}

@@ -647,17 +718,39 @@ function triggerRef(ref) {

}
function customRef(factory) {
const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value'));
const r = {
__v_isRef: true,
get value() {
return get();
},
set value(v) {
set(v);
const shallowUnwrapHandlers = {
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
};
return r;
else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs)
? objectWithRefs
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this.__v_isRef = true;
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
this._get = get;
this._set = set;
}
get value() {
return this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {
const ret = {};
const ret = shared.isArray(object) ? new Array(object.length) : {};
for (const key in object) {

@@ -668,14 +761,49 @@ ret[key] = toRef(object, key);

}
class ObjectRefImpl {
constructor(_object, _key) {
this._object = _object;
this._key = _key;
this.__v_isRef = true;
}
get value() {
return this._object[this._key];
}
set value(newVal) {
this._object[this._key] = newVal;
}
}
function toRef(object, key) {
return {
__v_isRef: true,
get value() {
return object[key];
},
set value(newVal) {
object[key] = newVal;
return isRef(object[key])
? object[key]
: new ObjectRefImpl(object, key);
}
class ComputedRefImpl {
constructor(getter, _setter, isReadonly) {
this._setter = _setter;
this._dirty = true;
this.__v_isRef = true;
this.effect = effect(getter, {
lazy: true,
scheduler: () => {
if (!this._dirty) {
this._dirty = true;
trigger(toRaw(this), "set" /* SET */, 'value');
}
}
});
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
}
get value() {
if (this._dirty) {
this._value = this.effect();
this._dirty = false;
}
};
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newValue) {
this._setter(newValue);
}
}
function computed(getterOrOptions) {

@@ -692,33 +820,3 @@ let getter;

}
let dirty = true;
let value;
let computed;
const runner = effect(getter, {
lazy: true,
// mark effect as computed so that it gets priority during trigger
computed: true,
scheduler: () => {
if (!dirty) {
dirty = true;
trigger(computed, "set" /* SET */, 'value');
}
}
});
computed = {
__v_isRef: true,
// expose effect so computed can be stopped
effect: runner,
get value() {
if (dirty) {
value = runner();
dirty = false;
}
track(computed, "get" /* GET */, 'value');
return value;
},
set value(newValue) {
setter(newValue);
}
};
return computed;
return new ComputedRefImpl(getter, setter, shared.isFunction(getterOrOptions) || !getterOrOptions.set);
}

@@ -737,2 +835,3 @@

exports.pauseTracking = pauseTracking;
exports.proxyRefs = proxyRefs;
exports.reactive = reactive;

@@ -739,0 +838,0 @@ exports.readonly = readonly;

+29
-13
dist/reactivity.d.ts
declare type BaseTypes = string | number | boolean;
declare type Builtin = Primitive | Function | Date | Error | RegExp;
declare type CollectionTypes = IterableCollections | WeakCollections;

@@ -38,2 +40,6 @@

export declare 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 {} ? {
readonly [K in keyof T]: DeepReadonly<T[K]>;
} : Readonly<T>;
declare type Dep = Set<ReactiveEffect>;

@@ -61,6 +67,10 @@

declare type Primitive = string | number | boolean | bigint | symbol | undefined | null;
export declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
export declare function reactive<T extends object>(target: T): UnwrapNestedRefs<T>;
export declare interface ReactiveEffect<T = any> {
(...args: any[]): T;
(): T;
_isEffect: true;

@@ -76,3 +86,2 @@ id: number;

lazy?: boolean;
computed?: boolean;
scheduler?: (job: ReactiveEffect) => void;

@@ -82,14 +91,13 @@ onTrack?: (event: DebuggerEvent) => void;

onStop?: () => void;
allowRecurse?: boolean;
}
export declare const enum ReactiveFlags {
skip = "__v_skip",
isReactive = "__v_isReactive",
isReadonly = "__v_isReadonly",
raw = "__v_raw",
reactive = "__v_reactive",
readonly = "__v_readonly"
SKIP = "__v_skip",
IS_REACTIVE = "__v_isReactive",
IS_READONLY = "__v_isReadonly",
RAW = "__v_raw"
}
export declare function readonly<T extends object>(target: T): Readonly<UnwrapNestedRefs<T>>;
export declare function readonly<T extends object>(target: T): DeepReadonly<UnwrapNestedRefs<T>>;

@@ -127,3 +135,3 @@ export declare interface Ref<T = any> {

*
* Note that api-extractor somehow refuses to include `decalre module`
* Note that api-extractor somehow refuses to include `declare module`
* augmentations in its generated d.ts, so we have to manually append them

@@ -143,6 +151,12 @@ * to the final generated d.ts in our build process.

export declare function shallowRef<T>(value: T): T extends Ref ? T : Ref<T>;
export declare function shallowRef<T extends object>(value: T): T extends Ref ? T : Ref<T>;
export declare function shallowRef<T>(value: T): Ref<T>;
export declare function shallowRef<T = any>(): Ref<T | undefined>;
export declare type ShallowUnwrapRef<T> = {
[K in keyof T]: T[K] extends Ref<infer V> ? V : T[K];
};
declare function stop_2(effect: ReactiveEffect): void;

@@ -242,5 +256,7 @@ export { stop_2 as stop }

export declare type UnwrapRef<T> = T extends ComputedRef<infer V> ? UnwrapRefSimple<V> : T extends Ref<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
export declare type UnwrapRef<T> = T extends Ref<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
declare type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] ? T : T extends Array<any> ? T : T extends object ? UnwrappedObject<T> : T;
declare type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] ? T : T extends Array<any> ? {
[K in keyof T]: UnwrapRefSimple<T[K]>;
} : T extends object ? UnwrappedObject<T> : T;

@@ -247,0 +263,0 @@ declare type WeakCollections = WeakMap<any, any> | WeakSet<any>;

+317
-222
dist/reactivity.esm-browser.js

@@ -1,21 +0,10 @@

// Make a map and return a function for checking if a key
// is in that map.
//
// IMPORTANT: all calls of this function must be prefixed with /*#__PURE__*/
// So that rollup can tree-shake them if necessary.
function makeMap(str, expectsLowerCase) {
const map = Object.create(null);
const list = str.split(',');
for (let i = 0; i < list.length; i++) {
map[list[i]] = true;
}
return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
}
const EMPTY_OBJ = Object.freeze({})
;
const extend = Object.assign;
const hasOwnProperty = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
const isArray = Array.isArray;
const isMap = (val) => toTypeString(val) === '[object Map]';
const isFunction = (val) => typeof val === 'function';
const isString = (val) => typeof val === 'string';
const isSymbol = (val) => typeof val === 'symbol';

@@ -28,2 +17,6 @@ const isObject = (val) => val !== null && typeof val === 'object';

};
const isIntegerKey = (key) => isString(key) &&
key !== 'NaN' &&
key[0] !== '-' &&
'' + parseInt(key, 10) === key;
const cacheStringFunction = (fn) => {

@@ -36,2 +29,5 @@ const cache = Object.create(null);

};
/**
* @private
*/
const capitalize = cacheStringFunction((str) => {

@@ -45,2 +41,3 @@ return str.charAt(0).toUpperCase() + str.slice(1);

configurable: true,
enumerable: false,
value

@@ -79,5 +76,5 @@ });

function createReactiveEffect(fn, options) {
const effect = function reactiveEffect(...args) {
const effect = function reactiveEffect() {
if (!effect.active) {
return options.scheduler ? undefined : fn(...args);
return options.scheduler ? undefined : fn();
}

@@ -90,3 +87,3 @@ if (!effectStack.includes(effect)) {

activeEffect = effect;
return fn(...args);
return fn();
}

@@ -163,13 +160,7 @@ finally {

const effects = new Set();
const computedRunners = new Set();
const add = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach(effect => {
if (effect !== activeEffect || !shouldTrack) {
if (effect.options.computed) {
computedRunners.add(effect);
}
else {
effects.add(effect);
}
if (effect !== activeEffect || effect.options.allowRecurse) {
effects.add(effect);
}

@@ -197,11 +188,29 @@ });

// also run for iteration key on ADD | DELETE | Map.SET
const isAddOrDelete = type === "add" /* ADD */ ||
(type === "delete" /* DELETE */ && !isArray(target));
if (isAddOrDelete ||
(type === "set" /* SET */ && target instanceof Map)) {
add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));
switch (type) {
case "add" /* ADD */:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
else if (isIntegerKey(key)) {
// new index added to array -> length changes
add(depsMap.get('length'));
}
break;
case "delete" /* DELETE */:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set" /* SET */:
if (isMap(target)) {
add(depsMap.get(ITERATE_KEY));
}
break;
}
if (isAddOrDelete && target instanceof Map) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}

@@ -227,5 +236,2 @@ const run = (effect) => {

};
// Important: computed effects must be run first so that computed getters
// can be invalidated before any normal effects that depend on them are run.
computedRunners.forEach(run);
effects.forEach(run);

@@ -243,2 +249,3 @@ }

['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {

@@ -250,6 +257,6 @@ const arr = toRaw(this);

// we run the method using the original args first (which may be reactive)
const res = arr[key](...args);
const res = method.apply(arr, args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return arr[key](...args.map(toRaw));
return method.apply(arr, args.map(toRaw));
}

@@ -261,11 +268,21 @@ else {

});
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {
pauseTracking();
const res = method.apply(this, args);
enableTracking();
return res;
};
});
function createGetter(isReadonly = false, shallow = false) {
return function get(target, key, receiver) {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */ || key === '__proto__') {
else if (key === "__v_raw" /* RAW */ &&
receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
return target;

@@ -278,27 +295,26 @@ }

const res = Reflect.get(target, key, receiver);
if (isSymbol(key) && builtInSymbols.has(key)) {
const keyIsSymbol = isSymbol(key);
if (keyIsSymbol
? builtInSymbols.has(key)
: key === `__proto__` || key === `__v_isRef`) {
return res;
}
if (!isReadonly) {
track(target, "get" /* GET */, key);
}
if (shallow) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
if (isRef(res)) {
if (targetIsArray) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
else {
// ref unwrapping, only for Objects, not for Arrays.
return res.value;
}
// ref unwrapping - does not apply for Array + integer key.
const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
return shouldUnwrap ? res.value : res;
}
!isReadonly && track(target, "get" /* GET */, key);
return isObject(res)
? isReadonly
? // need to lazy access readonly and reactive here to avoid
// circular dependency
readonly(res)
: reactive(res)
: res;
if (isObject(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};

@@ -318,3 +334,5 @@ }

}
const hadKey = hasOwn(target, key);
const hadKey = isArray(target) && isIntegerKey(key)
? Number(key) < target.length
: hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);

@@ -344,3 +362,5 @@ // don't trigger if target is something up in the prototype chain of original

const result = Reflect.has(target, key);
track(target, "has" /* HAS */, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has" /* HAS */, key);
}
return result;

@@ -361,4 +381,2 @@ }

get: readonlyGet,
has,
ownKeys,
set(target, key) {

@@ -377,47 +395,52 @@ {

};
const shallowReactiveHandlers = {
...mutableHandlers,
const shallowReactiveHandlers = extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
};
});
// Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
const shallowReadonlyHandlers = {
...readonlyHandlers,
const shallowReadonlyHandlers = extend({}, readonlyHandlers, {
get: shallowReadonlyGet
};
});
const toReactive = (value) => isObject(value) ? reactive(value) : value;
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, wrap) {
target = toRaw(target);
function get$1(target, key, isReadonly = false, isShallow = false) {
// #1772: readonly(reactive(Map)) should return readonly + reactive version
// of the value
target = target["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "get" /* GET */, key);
!isReadonly && track(rawTarget, "get" /* GET */, key);
}
track(target, "get" /* GET */, rawKey);
const { has, get } = getProto(target);
if (has.call(target, key)) {
return wrap(get.call(target, key));
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
const { has } = getProto(rawTarget);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
}
else if (has.call(target, rawKey)) {
return wrap(get.call(target, rawKey));
else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1(key) {
const target = toRaw(this);
function has$1(key, isReadonly = false) {
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "has" /* HAS */, key);
!isReadonly && track(rawTarget, "has" /* HAS */, key);
}
track(target, "has" /* HAS */, rawKey);
const has = getProto(target).has;
return has.call(target, key) || has.call(target, rawKey);
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
return key === rawKey
? target.has(key)
: target.has(key) || target.has(rawKey);
}
function size(target) {
target = toRaw(target);
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(getProto(target), 'size', target);
function size(target, isReadonly = false) {
target = target["__v_raw" /* RAW */];
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(target, 'size', target);
}

@@ -429,3 +452,3 @@ function add(value) {

const hadKey = proto.has.call(target, value);
const result = proto.add.call(target, value);
const result = target.add(value);
if (!hadKey) {

@@ -439,3 +462,3 @@ trigger(target, "add" /* ADD */, value, value);

const target = toRaw(this);
const { has, get, set } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -450,3 +473,3 @@ if (!hadKey) {

const oldValue = get.call(target, key);
const result = set.call(target, key, value);
const result = target.set(key, value);
if (!hadKey) {

@@ -462,3 +485,3 @@ trigger(target, "add" /* ADD */, key, value);

const target = toRaw(this);
const { has, get, delete: del } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -474,3 +497,3 @@ if (!hadKey) {

// forward the operation before queueing reactions
const result = del.call(target, key);
const result = target.delete(key);
if (hadKey) {

@@ -484,3 +507,3 @@ trigger(target, "delete" /* DELETE */, key, undefined, oldValue);

const hadItems = target.size !== 0;
const oldTarget = target instanceof Map
const oldTarget = isMap(target)
? new Map(target)

@@ -490,3 +513,3 @@ : new Set(target)

// forward the operation before queueing reactions
const result = getProto(target).clear.call(target);
const result = target.clear();
if (hadItems) {

@@ -497,27 +520,28 @@ trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);

}
function createForEach(isReadonly) {
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = toRaw(observed);
const wrap = isReadonly ? toReadonly : toReactive;
!isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY);
// important: create sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
function wrappedCallback(value, key) {
return callback.call(observed, wrap(value), wrap(key), observed);
}
return getProto(target).forEach.call(target, wrappedCallback, thisArg);
const target = observed["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
return target.forEach((value, key) => {
// important: make sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly) {
function createIterableMethod(method, isReadonly, isShallow) {
return function (...args) {
const target = toRaw(this);
const isMap = target instanceof Map;
const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
const isKeyOnly = method === 'keys' && isMap;
const innerIterator = getProto(target)[method].apply(target, args);
const wrap = isReadonly ? toReadonly : toReactive;
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const targetIsMap = isMap(rawTarget);
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
const isKeyOnly = method === 'keys' && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly &&
track(target, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
// return a wrapped iterator which returns observed versions of the

@@ -554,3 +578,3 @@ // values emitted from the real iterator

get(key) {
return get$1(this, key, toReactive);
return get$1(this, key);
},

@@ -565,7 +589,7 @@ get size() {

clear,
forEach: createForEach(false)
forEach: createForEach(false, false)
};
const readonlyInstrumentations = {
const shallowInstrumentations = {
get(key) {
return get$1(this, key, toReadonly);
return get$1(this, key, false, true);
},

@@ -576,2 +600,18 @@ get size() {

has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add" /* ADD */),

@@ -581,21 +621,24 @@ set: createReadonlyMethod("set" /* SET */),

clear: createReadonlyMethod("clear" /* CLEAR */),
forEach: createForEach(true)
forEach: createForEach(true, false)
};
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
iteratorMethods.forEach(method => {
mutableInstrumentations[method] = createIterableMethod(method, false);
readonlyInstrumentations[method] = createIterableMethod(method, true);
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly) {
const instrumentations = isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow
? shallowInstrumentations
: isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */) {
else if (key === "__v_raw" /* RAW */) {
return target;

@@ -609,6 +652,9 @@ }

const mutableCollectionHandlers = {
get: createInstrumentationGetter(false)
get: createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true)
get: createInstrumentationGetter(true, false)
};

@@ -627,12 +673,26 @@ function checkIdentityKeys(target, has, key) {

const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);
const isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');
const canObserve = (value) => {
return (!value.__v_skip &&
isObservableType(toRawType(value)) &&
!Object.isFrozen(value));
};
const reactiveMap = new WeakMap();
const readonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case 'Object':
case 'Array':
return 1 /* COMMON */;
case 'Map':
case 'Set':
case 'WeakMap':
case 'WeakSet':
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
? 0 /* INVALID */
: targetTypeMap(toRawType(value));
}
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target.__v_isReadonly) {
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
return target;

@@ -646,3 +706,3 @@ }

function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, mutableCollectionHandlers);
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
}

@@ -668,25 +728,29 @@ function readonly(target) {

// exception: calling readonly() on a reactive object
if (target.__v_raw && !(isReadonly && target.__v_isReactive)) {
if (target["__v_raw" /* RAW */] &&
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
return target;
}
// target already has corresponding Proxy
if (hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) {
return isReadonly ? target.__v_readonly : target.__v_reactive;
const proxyMap = isReadonly ? readonlyMap : reactiveMap;
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
// only a whitelist of value types can be observed.
if (!canObserve(target)) {
const targetType = getTargetType(target);
if (targetType === 0 /* INVALID */) {
return target;
}
const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed);
return observed;
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value.__v_raw);
return isReactive(value["__v_raw" /* RAW */]);
}
return !!(value && value.__v_isReactive);
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
}
function isReadonly(value) {
return !!(value && value.__v_isReadonly);
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
}

@@ -697,6 +761,6 @@ function isProxy(value) {

function toRaw(observed) {
return (observed && toRaw(observed.__v_raw)) || observed;
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
}
function markRaw(value) {
def(value, "__v_skip" /* skip */, true);
def(value, "__v_skip" /* SKIP */, true);
return value;

@@ -707,3 +771,3 @@ }

function isRef(r) {
return r ? r.__v_isRef === true : false;
return Boolean(r && r.__v_isRef === true);
}

@@ -716,2 +780,21 @@ function ref(value) {

}
class RefImpl {
constructor(_rawValue, _shallow = false) {
this._rawValue = _rawValue;
this._shallow = _shallow;
this.__v_isRef = true;
this._value = _shallow ? _rawValue : convert(_rawValue);
}
get value() {
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newVal) {
if (hasChanged(toRaw(newVal), this._rawValue)) {
this._rawValue = newVal;
this._value = this._shallow ? newVal : convert(newVal);
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
}
}
}
function createRef(rawValue, shallow = false) {

@@ -721,21 +804,6 @@ if (isRef(rawValue)) {

}
let value = shallow ? rawValue : convert(rawValue);
const r = {
__v_isRef: true,
get value() {
track(r, "get" /* GET */, 'value');
return value;
},
set value(newVal) {
if (hasChanged(toRaw(newVal), rawValue)) {
rawValue = newVal;
value = shallow ? newVal : convert(newVal);
trigger(r, "set" /* SET */, 'value', { newValue: newVal } );
}
}
};
return r;
return new RefImpl(rawValue, shallow);
}
function triggerRef(ref) {
trigger(ref, "set" /* SET */, 'value', { newValue: ref.value } );
trigger(ref, "set" /* SET */, 'value', ref.value );
}

@@ -745,15 +813,37 @@ function unref(ref) {

}
function customRef(factory) {
const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value'));
const r = {
__v_isRef: true,
get value() {
return get();
},
set value(v) {
set(v);
const shallowUnwrapHandlers = {
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
};
return r;
else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs)
? objectWithRefs
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this.__v_isRef = true;
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
this._get = get;
this._set = set;
}
get value() {
return this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {

@@ -763,3 +853,3 @@ if ( !isProxy(object)) {

}
const ret = {};
const ret = isArray(object) ? new Array(object.length) : {};
for (const key in object) {

@@ -770,14 +860,49 @@ ret[key] = toRef(object, key);

}
class ObjectRefImpl {
constructor(_object, _key) {
this._object = _object;
this._key = _key;
this.__v_isRef = true;
}
get value() {
return this._object[this._key];
}
set value(newVal) {
this._object[this._key] = newVal;
}
}
function toRef(object, key) {
return {
__v_isRef: true,
get value() {
return object[key];
},
set value(newVal) {
object[key] = newVal;
return isRef(object[key])
? object[key]
: new ObjectRefImpl(object, key);
}
class ComputedRefImpl {
constructor(getter, _setter, isReadonly) {
this._setter = _setter;
this._dirty = true;
this.__v_isRef = true;
this.effect = effect(getter, {
lazy: true,
scheduler: () => {
if (!this._dirty) {
this._dirty = true;
trigger(toRaw(this), "set" /* SET */, 'value');
}
}
});
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
}
get value() {
if (this._dirty) {
this._value = this.effect();
this._dirty = false;
}
};
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newValue) {
this._setter(newValue);
}
}
function computed(getterOrOptions) {

@@ -797,35 +922,5 @@ let getter;

}
let dirty = true;
let value;
let computed;
const runner = effect(getter, {
lazy: true,
// mark effect as computed so that it gets priority during trigger
computed: true,
scheduler: () => {
if (!dirty) {
dirty = true;
trigger(computed, "set" /* SET */, 'value');
}
}
});
computed = {
__v_isRef: true,
// expose effect so computed can be stopped
effect: runner,
get value() {
if (dirty) {
value = runner();
dirty = false;
}
track(computed, "get" /* GET */, 'value');
return value;
},
set value(newValue) {
setter(newValue);
}
};
return computed;
return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
}
export { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };
export { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };
+1
-1
dist/reactivity.esm-browser.prod.js

@@ -1,1 +0,1 @@

function t(t,e){const n=Object.create(null),r=t.split(",");for(let t=0;t<r.length;t++)n[r[t]]=!0;return e?t=>!!n[t.toLowerCase()]:t=>!!n[t]}const e={},n=()=>{},r=Object.prototype.hasOwnProperty,o=(t,e)=>r.call(t,e),c=Array.isArray,u=t=>"symbol"==typeof t,i=t=>null!==t&&"object"==typeof t,s=Object.prototype.toString,l=t=>(t=>s.call(t))(t).slice(8,-1),a=(t,e)=>t!==e&&(t==t||e==e),f=(t,e,n)=>{Object.defineProperty(t,e,{configurable:!0,value:n})},_=new WeakMap,v=[];let d;const h=Symbol(""),p=Symbol("");function g(t,n=e){(function(t){return t&&!0===t._isEffect})(t)&&(t=t.raw);const r=function(t,e){const n=function(...r){if(!n.active)return e.scheduler?void 0:t(...r);if(!v.includes(n)){w(n);try{return E(),v.push(n),d=n,t(...r)}finally{v.pop(),O(),d=v[v.length-1]}}};return n.id=R++,n._isEffect=!0,n.active=!0,n.raw=t,n.deps=[],n.options=e,n}(t,n);return n.lazy||r(),r}function y(t){t.active&&(w(t),t.options.onStop&&t.options.onStop(),t.active=!1)}let R=0;function w(t){const{deps:e}=t;if(e.length){for(let n=0;n<e.length;n++)e[n].delete(t);e.length=0}}let S=!0;const b=[];function m(){b.push(S),S=!1}function E(){b.push(S),S=!0}function O(){const t=b.pop();S=void 0===t||t}function k(t,e,n){if(!S||void 0===d)return;let r=_.get(t);r||_.set(t,r=new Map);let o=r.get(n);o||r.set(n,o=new Set),o.has(d)||(o.add(d),d.deps.push(o))}function M(t,e,n,r,o,u){const i=_.get(t);if(!i)return;const s=new Set,l=new Set,a=t=>{t&&t.forEach(t=>{t===d&&S||(t.options.computed?l.add(t):s.add(t))})};if("clear"===e)i.forEach(a);else if("length"===n&&c(t))i.forEach((t,e)=>{("length"===e||e>=r)&&a(t)});else{void 0!==n&&a(i.get(n));const r="add"===e||"delete"===e&&!c(t);(r||"set"===e&&t instanceof Map)&&a(i.get(c(t)?"length":h)),r&&t instanceof Map&&a(i.get(p))}const f=t=>{t.options.scheduler?t.options.scheduler(t):t()};l.forEach(f),s.forEach(f)}const j=new Set(Object.getOwnPropertyNames(Symbol).map(t=>Symbol[t]).filter(u)),P=K(),z=K(!1,!0),x=K(!0),W=K(!0,!0),A={};function K(t=!1,e=!1){return function(n,r,s){if("__v_isReactive"===r)return!t;if("__v_isReadonly"===r)return t;if("__v_raw"===r||"__proto__"===r)return n;const l=c(n);if(l&&o(A,r))return Reflect.get(A,r,s);const a=Reflect.get(n,r,s);return u(r)&&j.has(r)?a:e?(!t&&k(n,0,r),a):gt(a)?l?(!t&&k(n,0,r),a):a.value:(!t&&k(n,0,r),i(a)?t?st(a):ut(a):a)}}["includes","indexOf","lastIndexOf"].forEach(t=>{A[t]=function(...e){const n=dt(this);for(let t=0,e=this.length;t<e;t++)k(n,0,t+"");const r=n[t](...e);return-1===r||!1===r?n[t](...e.map(dt)):r}});const C=I(),F=I(!0);function I(t=!1){return function(e,n,r,u){const i=e[n];if(!t&&(r=dt(r),!c(e)&&gt(i)&&!gt(r)))return i.value=r,!0;const s=o(e,n),l=Reflect.set(e,n,r,u);return e===dt(u)&&(s?a(r,i)&&M(e,"set",n,r):M(e,"add",n,r)),l}}function L(t,e){const n=Reflect.has(t,e);return k(t,0,e),n}function N(t){return k(t,0,h),Reflect.ownKeys(t)}const q={get:P,set:C,deleteProperty:function(t,e){const n=o(t,e),r=Reflect.deleteProperty(t,e);return r&&n&&M(t,"delete",e,void 0),r},has:L,ownKeys:N},B={get:x,has:L,ownKeys:N,set:(t,e)=>!0,deleteProperty:(t,e)=>!0},D={...q,get:z,set:F},G={...B,get:W},H=t=>i(t)?ut(t):t,J=t=>i(t)?st(t):t,Q=t=>Reflect.getPrototypeOf(t);function T(t,e,n){t=dt(t);const r=dt(e);e!==r&&k(t,0,e),k(t,0,r);const{has:o,get:c}=Q(t);return o.call(t,e)?n(c.call(t,e)):o.call(t,r)?n(c.call(t,r)):void 0}function U(t){const e=dt(this),n=dt(t);t!==n&&k(e,0,t),k(e,0,n);const r=Q(e).has;return r.call(e,t)||r.call(e,n)}function V(t){return k(t=dt(t),0,h),Reflect.get(Q(t),"size",t)}function X(t){return function(e,n){const r=this,o=dt(r),c=t?J:H;return!t&&k(o,0,h),Q(o).forEach.call(o,(function(t,n){return e.call(r,c(t),c(n),r)}),n)}}function Y(t,e){return function(...n){const r=dt(this),o=r instanceof Map,c="entries"===t||t===Symbol.iterator&&o,u="keys"===t&&o,i=Q(r)[t].apply(r,n),s=e?J:H;return!e&&k(r,0,u?p:h),{next(){const{value:t,done:e}=i.next();return e?{value:t,done:e}:{value:c?[s(t[0]),s(t[1])]:s(t),done:e}},[Symbol.iterator](){return this}}}}function Z(t){return function(...e){return"delete"!==t&&this}}const $={get(t){return T(this,t,H)},get size(){return V(this)},has:U,add:function(t){t=dt(t);const e=dt(this),n=Q(e),r=n.has.call(e,t),o=n.add.call(e,t);return r||M(e,"add",t,t),o},set:function(t,e){e=dt(e);const n=dt(this),{has:r,get:o,set:c}=Q(n);let u=r.call(n,t);u||(t=dt(t),u=r.call(n,t));const i=o.call(n,t),s=c.call(n,t,e);return u?a(e,i)&&M(n,"set",t,e):M(n,"add",t,e),s},delete:function(t){const e=dt(this),{has:n,get:r,delete:o}=Q(e);let c=n.call(e,t);c||(t=dt(t),c=n.call(e,t)),r&&r.call(e,t);const u=o.call(e,t);return c&&M(e,"delete",t,void 0),u},clear:function(){const t=dt(this),e=0!==t.size,n=Q(t).clear.call(t);return e&&M(t,"clear",void 0,void 0),n},forEach:X(!1)},tt={get(t){return T(this,t,J)},get size(){return V(this)},has:U,add:Z("add"),set:Z("set"),delete:Z("delete"),clear:Z("clear"),forEach:X(!0)};function et(t){const e=t?tt:$;return(n,r,c)=>"__v_isReactive"===r?!t:"__v_isReadonly"===r?t:"__v_raw"===r?n:Reflect.get(o(e,r)&&r in n?e:n,r,c)}["keys","values","entries",Symbol.iterator].forEach(t=>{$[t]=Y(t,!1),tt[t]=Y(t,!0)});const nt={get:et(!1)},rt={get:et(!0)},ot=new Set([Set,Map,WeakMap,WeakSet]),ct=t("Object,Array,Map,Set,WeakMap,WeakSet");function ut(t){return t&&t.__v_isReadonly?t:at(t,!1,q,nt)}function it(t){return at(t,!1,D,nt)}function st(t){return at(t,!0,B,rt)}function lt(t){return at(t,!0,G,rt)}function at(t,e,n,r){if(!i(t))return t;if(t.__v_raw&&(!e||!t.__v_isReactive))return t;if(o(t,e?"__v_readonly":"__v_reactive"))return e?t.__v_readonly:t.__v_reactive;if((c=t).__v_skip||!ct(l(c))||Object.isFrozen(c))return t;var c;const u=new Proxy(t,ot.has(t.constructor)?r:n);return f(t,e?"__v_readonly":"__v_reactive",u),u}function ft(t){return _t(t)?ft(t.__v_raw):!(!t||!t.__v_isReactive)}function _t(t){return!(!t||!t.__v_isReadonly)}function vt(t){return ft(t)||_t(t)}function dt(t){return t&&dt(t.__v_raw)||t}function ht(t){return f(t,"__v_skip",!0),t}const pt=t=>i(t)?ut(t):t;function gt(t){return!!t&&!0===t.__v_isRef}function yt(t){return wt(t)}function Rt(t){return wt(t,!0)}function wt(t,e=!1){if(gt(t))return t;let n=e?t:pt(t);const r={__v_isRef:!0,get value(){return k(r,0,"value"),n},set value(o){a(dt(o),t)&&(t=o,n=e?o:pt(o),M(r,"set","value",void 0))}};return r}function St(t){M(t,"set","value",void 0)}function bt(t){return gt(t)?t.value:t}function mt(t){const{get:e,set:n}=t(()=>k(r,0,"value"),()=>M(r,"set","value")),r={__v_isRef:!0,get value(){return e()},set value(t){n(t)}};return r}function Et(t){const e={};for(const n in t)e[n]=Ot(t,n);return e}function Ot(t,e){return{__v_isRef:!0,get value(){return t[e]},set value(n){t[e]=n}}}function kt(t){let e,r;"function"==typeof t?(e=t,r=n):(e=t.get,r=t.set);let o,c,u=!0;const i=g(e,{lazy:!0,computed:!0,scheduler:()=>{u||(u=!0,M(c,"set","value"))}});return c={__v_isRef:!0,effect:i,get value(){return u&&(o=i(),u=!1),k(c,0,"value"),o},set value(t){r(t)}},c}export{h as ITERATE_KEY,kt as computed,mt as customRef,g as effect,E as enableTracking,vt as isProxy,ft as isReactive,_t as isReadonly,gt as isRef,ht as markRaw,m as pauseTracking,ut as reactive,st as readonly,yt as ref,O as resetTracking,it as shallowReactive,lt as shallowReadonly,Rt as shallowRef,y as stop,dt as toRaw,Ot as toRef,Et as toRefs,k as track,M as trigger,St as triggerRef,bt as unref};
const t={},e=()=>{},n=Object.assign,r=Object.prototype.hasOwnProperty,s=(t,e)=>r.call(t,e),i=Array.isArray,o=t=>"[object Map]"===f(t),c=t=>"function"==typeof t,u=t=>"symbol"==typeof t,a=t=>null!==t&&"object"==typeof t,l=Object.prototype.toString,f=t=>l.call(t),_=t=>"string"==typeof t&&"NaN"!==t&&"-"!==t[0]&&""+parseInt(t,10)===t,h=(t,e)=>t!==e&&(t==t||e==e),v=new WeakMap,d=[];let p;const g=Symbol(""),y=Symbol("");function w(e,n=t){(function(t){return t&&!0===t._isEffect})(e)&&(e=e.raw);const r=function(t,e){const n=function(){if(!n.active)return e.scheduler?void 0:t();if(!d.includes(n)){S(n);try{return j(),d.push(n),p=n,t()}finally{d.pop(),O(),p=d[d.length-1]}}};return n.id=b++,n._isEffect=!0,n.active=!0,n.raw=t,n.deps=[],n.options=e,n}(e,n);return n.lazy||r(),r}function R(t){t.active&&(S(t),t.options.onStop&&t.options.onStop(),t.active=!1)}let b=0;function S(t){const{deps:e}=t;if(e.length){for(let n=0;n<e.length;n++)e[n].delete(t);e.length=0}}let k=!0;const E=[];function m(){E.push(k),k=!1}function j(){E.push(k),k=!0}function O(){const t=E.pop();k=void 0===t||t}function P(t,e,n){if(!k||void 0===p)return;let r=v.get(t);r||v.set(t,r=new Map);let s=r.get(n);s||r.set(n,s=new Set),s.has(p)||(s.add(p),p.deps.push(s))}function x(t,e,n,r,s,c){const u=v.get(t);if(!u)return;const a=new Set,l=t=>{t&&t.forEach(t=>{(t!==p||t.options.allowRecurse)&&a.add(t)})};if("clear"===e)u.forEach(l);else if("length"===n&&i(t))u.forEach((t,e)=>{("length"===e||e>=r)&&l(t)});else switch(void 0!==n&&l(u.get(n)),e){case"add":i(t)?_(n)&&l(u.get("length")):(l(u.get(g)),o(t)&&l(u.get(y)));break;case"delete":i(t)||(l(u.get(g)),o(t)&&l(u.get(y)));break;case"set":o(t)&&l(u.get(g))}a.forEach(t=>{t.options.scheduler?t.options.scheduler(t):t()})}const z=new Set(Object.getOwnPropertyNames(Symbol).map(t=>Symbol[t]).filter(u)),M=I(),A=I(!1,!0),W=I(!0),N=I(!0,!0),V={};function I(t=!1,e=!1){return function(n,r,o){if("__v_isReactive"===r)return!t;if("__v_isReadonly"===r)return t;if("__v_raw"===r&&o===(t?lt:at).get(n))return n;const c=i(n);if(c&&s(V,r))return Reflect.get(V,r,o);const l=Reflect.get(n,r,o);if(u(r)?z.has(r):"__proto__"===r||"__v_isRef"===r)return l;if(t||P(n,0,r),e)return l;if(kt(l)){return!c||!_(r)?l.value:l}return a(l)?t?vt(l):_t(l):l}}["includes","indexOf","lastIndexOf"].forEach(t=>{const e=Array.prototype[t];V[t]=function(...t){const n=Rt(this);for(let t=0,e=this.length;t<e;t++)P(n,0,t+"");const r=e.apply(n,t);return-1===r||!1===r?e.apply(n,t.map(Rt)):r}}),["push","pop","shift","unshift","splice"].forEach(t=>{const e=Array.prototype[t];V[t]=function(...t){m();const n=e.apply(this,t);return j(),n}});function K(t=!1){return function(e,n,r,o){const c=e[n];if(!t&&(r=Rt(r),!i(e)&&kt(c)&&!kt(r)))return c.value=r,!0;const u=i(e)&&_(n)?Number(n)<e.length:s(e,n),a=Reflect.set(e,n,r,o);return e===Rt(o)&&(u?h(r,c)&&x(e,"set",n,r):x(e,"add",n,r)),a}}const B={get:M,set:K(),deleteProperty:function(t,e){const n=s(t,e),r=Reflect.deleteProperty(t,e);return r&&n&&x(t,"delete",e,void 0),r},has:function(t,e){const n=Reflect.has(t,e);return u(e)&&z.has(e)||P(t,0,e),n},ownKeys:function(t){return P(t,0,g),Reflect.ownKeys(t)}},q={get:W,set:(t,e)=>!0,deleteProperty:(t,e)=>!0},C=n({},B,{get:A,set:K(!0)}),D=n({},q,{get:N}),F=t=>a(t)?_t(t):t,G=t=>a(t)?vt(t):t,H=t=>t,J=t=>Reflect.getPrototypeOf(t);function L(t,e,n=!1,r=!1){const s=Rt(t=t.__v_raw),i=Rt(e);e!==i&&!n&&P(s,0,e),!n&&P(s,0,i);const{has:o}=J(s),c=n?G:r?H:F;return o.call(s,e)?c(t.get(e)):o.call(s,i)?c(t.get(i)):void 0}function Q(t,e=!1){const n=this.__v_raw,r=Rt(n),s=Rt(t);return t!==s&&!e&&P(r,0,t),!e&&P(r,0,s),t===s?n.has(t):n.has(t)||n.has(s)}function T(t,e=!1){return t=t.__v_raw,!e&&P(Rt(t),0,g),Reflect.get(t,"size",t)}function U(t){t=Rt(t);const e=Rt(this),n=J(e).has.call(e,t),r=e.add(t);return n||x(e,"add",t,t),r}function X(t,e){e=Rt(e);const n=Rt(this),{has:r,get:s}=J(n);let i=r.call(n,t);i||(t=Rt(t),i=r.call(n,t));const o=s.call(n,t),c=n.set(t,e);return i?h(e,o)&&x(n,"set",t,e):x(n,"add",t,e),c}function Y(t){const e=Rt(this),{has:n,get:r}=J(e);let s=n.call(e,t);s||(t=Rt(t),s=n.call(e,t));r&&r.call(e,t);const i=e.delete(t);return s&&x(e,"delete",t,void 0),i}function Z(){const t=Rt(this),e=0!==t.size,n=t.clear();return e&&x(t,"clear",void 0,void 0),n}function $(t,e){return function(n,r){const s=this,i=s.__v_raw,o=Rt(i),c=t?G:e?H:F;return!t&&P(o,0,g),i.forEach((t,e)=>n.call(r,c(t),c(e),s))}}function tt(t,e,n){return function(...r){const s=this.__v_raw,i=Rt(s),c=o(i),u="entries"===t||t===Symbol.iterator&&c,a="keys"===t&&c,l=s[t](...r),f=e?G:n?H:F;return!e&&P(i,0,a?y:g),{next(){const{value:t,done:e}=l.next();return e?{value:t,done:e}:{value:u?[f(t[0]),f(t[1])]:f(t),done:e}},[Symbol.iterator](){return this}}}}function et(t){return function(...e){return"delete"!==t&&this}}const nt={get(t){return L(this,t)},get size(){return T(this)},has:Q,add:U,set:X,delete:Y,clear:Z,forEach:$(!1,!1)},rt={get(t){return L(this,t,!1,!0)},get size(){return T(this)},has:Q,add:U,set:X,delete:Y,clear:Z,forEach:$(!1,!0)},st={get(t){return L(this,t,!0)},get size(){return T(this,!0)},has(t){return Q.call(this,t,!0)},add:et("add"),set:et("set"),delete:et("delete"),clear:et("clear"),forEach:$(!0,!1)};function it(t,e){const n=e?rt:t?st:nt;return(e,r,i)=>"__v_isReactive"===r?!t:"__v_isReadonly"===r?t:"__v_raw"===r?e:Reflect.get(s(n,r)&&r in e?n:e,r,i)}["keys","values","entries",Symbol.iterator].forEach(t=>{nt[t]=tt(t,!1,!1),st[t]=tt(t,!0,!1),rt[t]=tt(t,!1,!0)});const ot={get:it(!1,!1)},ct={get:it(!1,!0)},ut={get:it(!0,!1)},at=new WeakMap,lt=new WeakMap;function ft(t){return t.__v_skip||!Object.isExtensible(t)?0:function(t){switch(t){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}((t=>f(t).slice(8,-1))(t))}function _t(t){return t&&t.__v_isReadonly?t:pt(t,!1,B,ot)}function ht(t){return pt(t,!1,C,ct)}function vt(t){return pt(t,!0,q,ut)}function dt(t){return pt(t,!0,D,ut)}function pt(t,e,n,r){if(!a(t))return t;if(t.__v_raw&&(!e||!t.__v_isReactive))return t;const s=e?lt:at,i=s.get(t);if(i)return i;const o=ft(t);if(0===o)return t;const c=new Proxy(t,2===o?r:n);return s.set(t,c),c}function gt(t){return yt(t)?gt(t.__v_raw):!(!t||!t.__v_isReactive)}function yt(t){return!(!t||!t.__v_isReadonly)}function wt(t){return gt(t)||yt(t)}function Rt(t){return t&&Rt(t.__v_raw)||t}function bt(t){return((t,e,n)=>{Object.defineProperty(t,e,{configurable:!0,enumerable:!1,value:n})})(t,"__v_skip",!0),t}const St=t=>a(t)?_t(t):t;function kt(t){return Boolean(t&&!0===t.__v_isRef)}function Et(t){return Ot(t)}function mt(t){return Ot(t,!0)}class jt{constructor(t,e=!1){this._rawValue=t,this._shallow=e,this.__v_isRef=!0,this._value=e?t:St(t)}get value(){return P(Rt(this),0,"value"),this._value}set value(t){h(Rt(t),this._rawValue)&&(this._rawValue=t,this._value=this._shallow?t:St(t),x(Rt(this),"set","value",t))}}function Ot(t,e=!1){return kt(t)?t:new jt(t,e)}function Pt(t){x(t,"set","value",void 0)}function xt(t){return kt(t)?t.value:t}const zt={get:(t,e,n)=>xt(Reflect.get(t,e,n)),set:(t,e,n,r)=>{const s=t[e];return kt(s)&&!kt(n)?(s.value=n,!0):Reflect.set(t,e,n,r)}};function Mt(t){return gt(t)?t:new Proxy(t,zt)}class At{constructor(t){this.__v_isRef=!0;const{get:e,set:n}=t(()=>P(this,0,"value"),()=>x(this,"set","value"));this._get=e,this._set=n}get value(){return this._get()}set value(t){this._set(t)}}function Wt(t){return new At(t)}function Nt(t){const e=i(t)?new Array(t.length):{};for(const n in t)e[n]=It(t,n);return e}class Vt{constructor(t,e){this._object=t,this._key=e,this.__v_isRef=!0}get value(){return this._object[this._key]}set value(t){this._object[this._key]=t}}function It(t,e){return kt(t[e])?t[e]:new Vt(t,e)}class Kt{constructor(t,e,n){this._setter=e,this._dirty=!0,this.__v_isRef=!0,this.effect=w(t,{lazy:!0,scheduler:()=>{this._dirty||(this._dirty=!0,x(Rt(this),"set","value"))}}),this.__v_isReadonly=n}get value(){return this._dirty&&(this._value=this.effect(),this._dirty=!1),P(Rt(this),0,"value"),this._value}set value(t){this._setter(t)}}function Bt(t){let n,r;return c(t)?(n=t,r=e):(n=t.get,r=t.set),new Kt(n,r,c(t)||!t.set)}export{g as ITERATE_KEY,Bt as computed,Wt as customRef,w as effect,j as enableTracking,wt as isProxy,gt as isReactive,yt as isReadonly,kt as isRef,bt as markRaw,m as pauseTracking,Mt as proxyRefs,_t as reactive,vt as readonly,Et as ref,O as resetTracking,ht as shallowReactive,dt as shallowReadonly,mt as shallowRef,R as stop,Rt as toRaw,It as toRef,Nt as toRefs,P as track,x as trigger,Pt as triggerRef,xt as unref};
+307
-209
dist/reactivity.esm-bundler.js

@@ -1,2 +0,2 @@

import { EMPTY_OBJ, isArray, isSymbol, hasOwn, isObject, hasChanged, capitalize, toRawType, def, makeMap, isFunction, NOOP } from '@atom-vue/shared';
import { EMPTY_OBJ, isArray, isMap, isIntegerKey, isSymbol, extend, hasOwn, isObject, hasChanged, capitalize, toRawType, def, isFunction, NOOP } from '@atom-vue/shared';

@@ -32,5 +32,5 @@ const targetMap = new WeakMap();

function createReactiveEffect(fn, options) {
const effect = function reactiveEffect(...args) {
const effect = function reactiveEffect() {
if (!effect.active) {
return options.scheduler ? undefined : fn(...args);
return options.scheduler ? undefined : fn();
}

@@ -43,3 +43,3 @@ if (!effectStack.includes(effect)) {

activeEffect = effect;
return fn(...args);
return fn();
}

@@ -116,13 +116,7 @@ finally {

const effects = new Set();
const computedRunners = new Set();
const add = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach(effect => {
if (effect !== activeEffect || !shouldTrack) {
if (effect.options.computed) {
computedRunners.add(effect);
}
else {
effects.add(effect);
}
if (effect !== activeEffect || effect.options.allowRecurse) {
effects.add(effect);
}

@@ -150,11 +144,29 @@ });

// also run for iteration key on ADD | DELETE | Map.SET
const isAddOrDelete = type === "add" /* ADD */ ||
(type === "delete" /* DELETE */ && !isArray(target));
if (isAddOrDelete ||
(type === "set" /* SET */ && target instanceof Map)) {
add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));
switch (type) {
case "add" /* ADD */:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
else if (isIntegerKey(key)) {
// new index added to array -> length changes
add(depsMap.get('length'));
}
break;
case "delete" /* DELETE */:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set" /* SET */:
if (isMap(target)) {
add(depsMap.get(ITERATE_KEY));
}
break;
}
if (isAddOrDelete && target instanceof Map) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}

@@ -180,5 +192,2 @@ const run = (effect) => {

};
// Important: computed effects must be run first so that computed getters
// can be invalidated before any normal effects that depend on them are run.
computedRunners.forEach(run);
effects.forEach(run);

@@ -196,2 +205,3 @@ }

['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {

@@ -203,6 +213,6 @@ const arr = toRaw(this);

// we run the method using the original args first (which may be reactive)
const res = arr[key](...args);
const res = method.apply(arr, args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return arr[key](...args.map(toRaw));
return method.apply(arr, args.map(toRaw));
}

@@ -214,11 +224,21 @@ else {

});
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {
pauseTracking();
const res = method.apply(this, args);
enableTracking();
return res;
};
});
function createGetter(isReadonly = false, shallow = false) {
return function get(target, key, receiver) {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */ || key === '__proto__') {
else if (key === "__v_raw" /* RAW */ &&
receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
return target;

@@ -231,27 +251,26 @@ }

const res = Reflect.get(target, key, receiver);
if (isSymbol(key) && builtInSymbols.has(key)) {
const keyIsSymbol = isSymbol(key);
if (keyIsSymbol
? builtInSymbols.has(key)
: key === `__proto__` || key === `__v_isRef`) {
return res;
}
if (!isReadonly) {
track(target, "get" /* GET */, key);
}
if (shallow) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
if (isRef(res)) {
if (targetIsArray) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
else {
// ref unwrapping, only for Objects, not for Arrays.
return res.value;
}
// ref unwrapping - does not apply for Array + integer key.
const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
return shouldUnwrap ? res.value : res;
}
!isReadonly && track(target, "get" /* GET */, key);
return isObject(res)
? isReadonly
? // need to lazy access readonly and reactive here to avoid
// circular dependency
readonly(res)
: reactive(res)
: res;
if (isObject(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};

@@ -271,3 +290,5 @@ }

}
const hadKey = hasOwn(target, key);
const hadKey = isArray(target) && isIntegerKey(key)
? Number(key) < target.length
: hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);

@@ -297,3 +318,5 @@ // don't trigger if target is something up in the prototype chain of original

const result = Reflect.has(target, key);
track(target, "has" /* HAS */, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has" /* HAS */, key);
}
return result;

@@ -314,4 +337,2 @@ }

get: readonlyGet,
has,
ownKeys,
set(target, key) {

@@ -330,47 +351,52 @@ if ((process.env.NODE_ENV !== 'production')) {

};
const shallowReactiveHandlers = {
...mutableHandlers,
const shallowReactiveHandlers = extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
};
});
// Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
const shallowReadonlyHandlers = {
...readonlyHandlers,
const shallowReadonlyHandlers = extend({}, readonlyHandlers, {
get: shallowReadonlyGet
};
});
const toReactive = (value) => isObject(value) ? reactive(value) : value;
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, wrap) {
target = toRaw(target);
function get$1(target, key, isReadonly = false, isShallow = false) {
// #1772: readonly(reactive(Map)) should return readonly + reactive version
// of the value
target = target["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "get" /* GET */, key);
!isReadonly && track(rawTarget, "get" /* GET */, key);
}
track(target, "get" /* GET */, rawKey);
const { has, get } = getProto(target);
if (has.call(target, key)) {
return wrap(get.call(target, key));
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
const { has } = getProto(rawTarget);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
}
else if (has.call(target, rawKey)) {
return wrap(get.call(target, rawKey));
else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1(key) {
const target = toRaw(this);
function has$1(key, isReadonly = false) {
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "has" /* HAS */, key);
!isReadonly && track(rawTarget, "has" /* HAS */, key);
}
track(target, "has" /* HAS */, rawKey);
const has = getProto(target).has;
return has.call(target, key) || has.call(target, rawKey);
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
return key === rawKey
? target.has(key)
: target.has(key) || target.has(rawKey);
}
function size(target) {
target = toRaw(target);
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(getProto(target), 'size', target);
function size(target, isReadonly = false) {
target = target["__v_raw" /* RAW */];
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(target, 'size', target);
}

@@ -382,3 +408,3 @@ function add(value) {

const hadKey = proto.has.call(target, value);
const result = proto.add.call(target, value);
const result = target.add(value);
if (!hadKey) {

@@ -392,3 +418,3 @@ trigger(target, "add" /* ADD */, value, value);

const target = toRaw(this);
const { has, get, set } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -403,3 +429,3 @@ if (!hadKey) {

const oldValue = get.call(target, key);
const result = set.call(target, key, value);
const result = target.set(key, value);
if (!hadKey) {

@@ -415,3 +441,3 @@ trigger(target, "add" /* ADD */, key, value);

const target = toRaw(this);
const { has, get, delete: del } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -427,3 +453,3 @@ if (!hadKey) {

// forward the operation before queueing reactions
const result = del.call(target, key);
const result = target.delete(key);
if (hadKey) {

@@ -438,3 +464,3 @@ trigger(target, "delete" /* DELETE */, key, undefined, oldValue);

const oldTarget = (process.env.NODE_ENV !== 'production')
? target instanceof Map
? isMap(target)
? new Map(target)

@@ -444,3 +470,3 @@ : new Set(target)

// forward the operation before queueing reactions
const result = getProto(target).clear.call(target);
const result = target.clear();
if (hadItems) {

@@ -451,27 +477,28 @@ trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);

}
function createForEach(isReadonly) {
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = toRaw(observed);
const wrap = isReadonly ? toReadonly : toReactive;
!isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY);
// important: create sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
function wrappedCallback(value, key) {
return callback.call(observed, wrap(value), wrap(key), observed);
}
return getProto(target).forEach.call(target, wrappedCallback, thisArg);
const target = observed["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
return target.forEach((value, key) => {
// important: make sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly) {
function createIterableMethod(method, isReadonly, isShallow) {
return function (...args) {
const target = toRaw(this);
const isMap = target instanceof Map;
const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
const isKeyOnly = method === 'keys' && isMap;
const innerIterator = getProto(target)[method].apply(target, args);
const wrap = isReadonly ? toReadonly : toReactive;
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const targetIsMap = isMap(rawTarget);
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
const isKeyOnly = method === 'keys' && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly &&
track(target, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
// return a wrapped iterator which returns observed versions of the

@@ -508,3 +535,3 @@ // values emitted from the real iterator

get(key) {
return get$1(this, key, toReactive);
return get$1(this, key);
},

@@ -519,7 +546,7 @@ get size() {

clear,
forEach: createForEach(false)
forEach: createForEach(false, false)
};
const readonlyInstrumentations = {
const shallowInstrumentations = {
get(key) {
return get$1(this, key, toReadonly);
return get$1(this, key, false, true);
},

@@ -530,2 +557,18 @@ get size() {

has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add" /* ADD */),

@@ -535,21 +578,24 @@ set: createReadonlyMethod("set" /* SET */),

clear: createReadonlyMethod("clear" /* CLEAR */),
forEach: createForEach(true)
forEach: createForEach(true, false)
};
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
iteratorMethods.forEach(method => {
mutableInstrumentations[method] = createIterableMethod(method, false);
readonlyInstrumentations[method] = createIterableMethod(method, true);
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly) {
const instrumentations = isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow
? shallowInstrumentations
: isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */) {
else if (key === "__v_raw" /* RAW */) {
return target;

@@ -563,6 +609,9 @@ }

const mutableCollectionHandlers = {
get: createInstrumentationGetter(false)
get: createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true)
get: createInstrumentationGetter(true, false)
};

@@ -581,12 +630,26 @@ function checkIdentityKeys(target, has, key) {

const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);
const isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');
const canObserve = (value) => {
return (!value.__v_skip &&
isObservableType(toRawType(value)) &&
!Object.isFrozen(value));
};
const reactiveMap = new WeakMap();
const readonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case 'Object':
case 'Array':
return 1 /* COMMON */;
case 'Map':
case 'Set':
case 'WeakMap':
case 'WeakSet':
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
? 0 /* INVALID */
: targetTypeMap(toRawType(value));
}
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target.__v_isReadonly) {
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
return target;

@@ -600,3 +663,3 @@ }

function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, mutableCollectionHandlers);
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
}

@@ -622,25 +685,29 @@ function readonly(target) {

// exception: calling readonly() on a reactive object
if (target.__v_raw && !(isReadonly && target.__v_isReactive)) {
if (target["__v_raw" /* RAW */] &&
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
return target;
}
// target already has corresponding Proxy
if (hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) {
return isReadonly ? target.__v_readonly : target.__v_reactive;
const proxyMap = isReadonly ? readonlyMap : reactiveMap;
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
// only a whitelist of value types can be observed.
if (!canObserve(target)) {
const targetType = getTargetType(target);
if (targetType === 0 /* INVALID */) {
return target;
}
const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed);
return observed;
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value.__v_raw);
return isReactive(value["__v_raw" /* RAW */]);
}
return !!(value && value.__v_isReactive);
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
}
function isReadonly(value) {
return !!(value && value.__v_isReadonly);
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
}

@@ -651,6 +718,6 @@ function isProxy(value) {

function toRaw(observed) {
return (observed && toRaw(observed.__v_raw)) || observed;
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
}
function markRaw(value) {
def(value, "__v_skip" /* skip */, true);
def(value, "__v_skip" /* SKIP */, true);
return value;

@@ -661,3 +728,3 @@ }

function isRef(r) {
return r ? r.__v_isRef === true : false;
return Boolean(r && r.__v_isRef === true);
}

@@ -670,2 +737,21 @@ function ref(value) {

}
class RefImpl {
constructor(_rawValue, _shallow = false) {
this._rawValue = _rawValue;
this._shallow = _shallow;
this.__v_isRef = true;
this._value = _shallow ? _rawValue : convert(_rawValue);
}
get value() {
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newVal) {
if (hasChanged(toRaw(newVal), this._rawValue)) {
this._rawValue = newVal;
this._value = this._shallow ? newVal : convert(newVal);
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
}
}
}
function createRef(rawValue, shallow = false) {

@@ -675,21 +761,6 @@ if (isRef(rawValue)) {

}
let value = shallow ? rawValue : convert(rawValue);
const r = {
__v_isRef: true,
get value() {
track(r, "get" /* GET */, 'value');
return value;
},
set value(newVal) {
if (hasChanged(toRaw(newVal), rawValue)) {
rawValue = newVal;
value = shallow ? newVal : convert(newVal);
trigger(r, "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? { newValue: newVal } : void 0);
}
}
};
return r;
return new RefImpl(rawValue, shallow);
}
function triggerRef(ref) {
trigger(ref, "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? { newValue: ref.value } : void 0);
trigger(ref, "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? ref.value : void 0);
}

@@ -699,15 +770,37 @@ function unref(ref) {

}
function customRef(factory) {
const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value'));
const r = {
__v_isRef: true,
get value() {
return get();
},
set value(v) {
set(v);
const shallowUnwrapHandlers = {
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
};
return r;
else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs)
? objectWithRefs
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this.__v_isRef = true;
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
this._get = get;
this._set = set;
}
get value() {
return this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {

@@ -717,3 +810,3 @@ if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) {

}
const ret = {};
const ret = isArray(object) ? new Array(object.length) : {};
for (const key in object) {

@@ -724,14 +817,49 @@ ret[key] = toRef(object, key);

}
class ObjectRefImpl {
constructor(_object, _key) {
this._object = _object;
this._key = _key;
this.__v_isRef = true;
}
get value() {
return this._object[this._key];
}
set value(newVal) {
this._object[this._key] = newVal;
}
}
function toRef(object, key) {
return {
__v_isRef: true,
get value() {
return object[key];
},
set value(newVal) {
object[key] = newVal;
return isRef(object[key])
? object[key]
: new ObjectRefImpl(object, key);
}
class ComputedRefImpl {
constructor(getter, _setter, isReadonly) {
this._setter = _setter;
this._dirty = true;
this.__v_isRef = true;
this.effect = effect(getter, {
lazy: true,
scheduler: () => {
if (!this._dirty) {
this._dirty = true;
trigger(toRaw(this), "set" /* SET */, 'value');
}
}
});
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
}
get value() {
if (this._dirty) {
this._value = this.effect();
this._dirty = false;
}
};
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newValue) {
this._setter(newValue);
}
}
function computed(getterOrOptions) {

@@ -752,35 +880,5 @@ let getter;

}
let dirty = true;
let value;
let computed;
const runner = effect(getter, {
lazy: true,
// mark effect as computed so that it gets priority during trigger
computed: true,
scheduler: () => {
if (!dirty) {
dirty = true;
trigger(computed, "set" /* SET */, 'value');
}
}
});
computed = {
__v_isRef: true,
// expose effect so computed can be stopped
effect: runner,
get value() {
if (dirty) {
value = runner();
dirty = false;
}
track(computed, "get" /* GET */, 'value');
return value;
},
set value(newValue) {
setter(newValue);
}
};
return computed;
return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
}
export { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };
export { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };
+317
-221
dist/reactivity.global.js
var VueReactivity = (function (exports) {
'use strict';
// Make a map and return a function for checking if a key
// is in that map.
//
// IMPORTANT: all calls of this function must be prefixed with /*#__PURE__*/
// So that rollup can tree-shake them if necessary.
function makeMap(str, expectsLowerCase) {
const map = Object.create(null);
const list = str.split(',');
for (let i = 0; i < list.length; i++) {
map[list[i]] = true;
}
return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
}
const EMPTY_OBJ = Object.freeze({})
;
const extend = Object.assign;
const hasOwnProperty = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
const isArray = Array.isArray;
const isMap = (val) => toTypeString(val) === '[object Map]';
const isFunction = (val) => typeof val === 'function';
const isString = (val) => typeof val === 'string';
const isSymbol = (val) => typeof val === 'symbol';

@@ -31,2 +20,6 @@ const isObject = (val) => val !== null && typeof val === 'object';

};
const isIntegerKey = (key) => isString(key) &&
key !== 'NaN' &&
key[0] !== '-' &&
'' + parseInt(key, 10) === key;
const cacheStringFunction = (fn) => {

@@ -39,2 +32,5 @@ const cache = Object.create(null);

};
/**
* @private
*/
const capitalize = cacheStringFunction((str) => {

@@ -48,2 +44,3 @@ return str.charAt(0).toUpperCase() + str.slice(1);

configurable: true,
enumerable: false,
value

@@ -82,5 +79,5 @@ });

function createReactiveEffect(fn, options) {
const effect = function reactiveEffect(...args) {
const effect = function reactiveEffect() {
if (!effect.active) {
return options.scheduler ? undefined : fn(...args);
return options.scheduler ? undefined : fn();
}

@@ -93,3 +90,3 @@ if (!effectStack.includes(effect)) {

activeEffect = effect;
return fn(...args);
return fn();
}

@@ -166,13 +163,7 @@ finally {

const effects = new Set();
const computedRunners = new Set();
const add = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach(effect => {
if (effect !== activeEffect || !shouldTrack) {
if (effect.options.computed) {
computedRunners.add(effect);
}
else {
effects.add(effect);
}
if (effect !== activeEffect || effect.options.allowRecurse) {
effects.add(effect);
}

@@ -200,11 +191,29 @@ });

// also run for iteration key on ADD | DELETE | Map.SET
const isAddOrDelete = type === "add" /* ADD */ ||
(type === "delete" /* DELETE */ && !isArray(target));
if (isAddOrDelete ||
(type === "set" /* SET */ && target instanceof Map)) {
add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));
switch (type) {
case "add" /* ADD */:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
else if (isIntegerKey(key)) {
// new index added to array -> length changes
add(depsMap.get('length'));
}
break;
case "delete" /* DELETE */:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set" /* SET */:
if (isMap(target)) {
add(depsMap.get(ITERATE_KEY));
}
break;
}
if (isAddOrDelete && target instanceof Map) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}

@@ -230,5 +239,2 @@ const run = (effect) => {

};
// Important: computed effects must be run first so that computed getters
// can be invalidated before any normal effects that depend on them are run.
computedRunners.forEach(run);
effects.forEach(run);

@@ -246,2 +252,3 @@ }

['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {

@@ -253,6 +260,6 @@ const arr = toRaw(this);

// we run the method using the original args first (which may be reactive)
const res = arr[key](...args);
const res = method.apply(arr, args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return arr[key](...args.map(toRaw));
return method.apply(arr, args.map(toRaw));
}

@@ -264,11 +271,21 @@ else {

});
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function (...args) {
pauseTracking();
const res = method.apply(this, args);
enableTracking();
return res;
};
});
function createGetter(isReadonly = false, shallow = false) {
return function get(target, key, receiver) {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */ || key === '__proto__') {
else if (key === "__v_raw" /* RAW */ &&
receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
return target;

@@ -281,27 +298,26 @@ }

const res = Reflect.get(target, key, receiver);
if (isSymbol(key) && builtInSymbols.has(key)) {
const keyIsSymbol = isSymbol(key);
if (keyIsSymbol
? builtInSymbols.has(key)
: key === `__proto__` || key === `__v_isRef`) {
return res;
}
if (!isReadonly) {
track(target, "get" /* GET */, key);
}
if (shallow) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
if (isRef(res)) {
if (targetIsArray) {
!isReadonly && track(target, "get" /* GET */, key);
return res;
}
else {
// ref unwrapping, only for Objects, not for Arrays.
return res.value;
}
// ref unwrapping - does not apply for Array + integer key.
const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
return shouldUnwrap ? res.value : res;
}
!isReadonly && track(target, "get" /* GET */, key);
return isObject(res)
? isReadonly
? // need to lazy access readonly and reactive here to avoid
// circular dependency
readonly(res)
: reactive(res)
: res;
if (isObject(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};

@@ -321,3 +337,5 @@ }

}
const hadKey = hasOwn(target, key);
const hadKey = isArray(target) && isIntegerKey(key)
? Number(key) < target.length
: hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);

@@ -347,3 +365,5 @@ // don't trigger if target is something up in the prototype chain of original

const result = Reflect.has(target, key);
track(target, "has" /* HAS */, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has" /* HAS */, key);
}
return result;

@@ -364,4 +384,2 @@ }

get: readonlyGet,
has,
ownKeys,
set(target, key) {

@@ -380,47 +398,52 @@ {

};
const shallowReactiveHandlers = {
...mutableHandlers,
const shallowReactiveHandlers = extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
};
});
// Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
const shallowReadonlyHandlers = {
...readonlyHandlers,
const shallowReadonlyHandlers = extend({}, readonlyHandlers, {
get: shallowReadonlyGet
};
});
const toReactive = (value) => isObject(value) ? reactive(value) : value;
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, wrap) {
target = toRaw(target);
function get$1(target, key, isReadonly = false, isShallow = false) {
// #1772: readonly(reactive(Map)) should return readonly + reactive version
// of the value
target = target["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "get" /* GET */, key);
!isReadonly && track(rawTarget, "get" /* GET */, key);
}
track(target, "get" /* GET */, rawKey);
const { has, get } = getProto(target);
if (has.call(target, key)) {
return wrap(get.call(target, key));
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
const { has } = getProto(rawTarget);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
}
else if (has.call(target, rawKey)) {
return wrap(get.call(target, rawKey));
else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1(key) {
const target = toRaw(this);
function has$1(key, isReadonly = false) {
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "has" /* HAS */, key);
!isReadonly && track(rawTarget, "has" /* HAS */, key);
}
track(target, "has" /* HAS */, rawKey);
const has = getProto(target).has;
return has.call(target, key) || has.call(target, rawKey);
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
return key === rawKey
? target.has(key)
: target.has(key) || target.has(rawKey);
}
function size(target) {
target = toRaw(target);
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(getProto(target), 'size', target);
function size(target, isReadonly = false) {
target = target["__v_raw" /* RAW */];
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(target, 'size', target);
}

@@ -432,3 +455,3 @@ function add(value) {

const hadKey = proto.has.call(target, value);
const result = proto.add.call(target, value);
const result = target.add(value);
if (!hadKey) {

@@ -442,3 +465,3 @@ trigger(target, "add" /* ADD */, value, value);

const target = toRaw(this);
const { has, get, set } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -453,3 +476,3 @@ if (!hadKey) {

const oldValue = get.call(target, key);
const result = set.call(target, key, value);
const result = target.set(key, value);
if (!hadKey) {

@@ -465,3 +488,3 @@ trigger(target, "add" /* ADD */, key, value);

const target = toRaw(this);
const { has, get, delete: del } = getProto(target);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);

@@ -477,3 +500,3 @@ if (!hadKey) {

// forward the operation before queueing reactions
const result = del.call(target, key);
const result = target.delete(key);
if (hadKey) {

@@ -487,3 +510,3 @@ trigger(target, "delete" /* DELETE */, key, undefined, oldValue);

const hadItems = target.size !== 0;
const oldTarget = target instanceof Map
const oldTarget = isMap(target)
? new Map(target)

@@ -493,3 +516,3 @@ : new Set(target)

// forward the operation before queueing reactions
const result = getProto(target).clear.call(target);
const result = target.clear();
if (hadItems) {

@@ -500,27 +523,28 @@ trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);

}
function createForEach(isReadonly) {
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = toRaw(observed);
const wrap = isReadonly ? toReadonly : toReactive;
!isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY);
// important: create sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
function wrappedCallback(value, key) {
return callback.call(observed, wrap(value), wrap(key), observed);
}
return getProto(target).forEach.call(target, wrappedCallback, thisArg);
const target = observed["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
return target.forEach((value, key) => {
// important: make sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly) {
function createIterableMethod(method, isReadonly, isShallow) {
return function (...args) {
const target = toRaw(this);
const isMap = target instanceof Map;
const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
const isKeyOnly = method === 'keys' && isMap;
const innerIterator = getProto(target)[method].apply(target, args);
const wrap = isReadonly ? toReadonly : toReactive;
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const targetIsMap = isMap(rawTarget);
const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
const isKeyOnly = method === 'keys' && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly &&
track(target, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
// return a wrapped iterator which returns observed versions of the

@@ -557,3 +581,3 @@ // values emitted from the real iterator

get(key) {
return get$1(this, key, toReactive);
return get$1(this, key);
},

@@ -568,7 +592,7 @@ get size() {

clear,
forEach: createForEach(false)
forEach: createForEach(false, false)
};
const readonlyInstrumentations = {
const shallowInstrumentations = {
get(key) {
return get$1(this, key, toReadonly);
return get$1(this, key, false, true);
},

@@ -579,2 +603,18 @@ get size() {

has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add" /* ADD */),

@@ -584,21 +624,24 @@ set: createReadonlyMethod("set" /* SET */),

clear: createReadonlyMethod("clear" /* CLEAR */),
forEach: createForEach(true)
forEach: createForEach(true, false)
};
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
iteratorMethods.forEach(method => {
mutableInstrumentations[method] = createIterableMethod(method, false);
readonlyInstrumentations[method] = createIterableMethod(method, true);
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly) {
const instrumentations = isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow
? shallowInstrumentations
: isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive" /* isReactive */) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */) {
else if (key === "__v_raw" /* RAW */) {
return target;

@@ -612,6 +655,9 @@ }

const mutableCollectionHandlers = {
get: createInstrumentationGetter(false)
get: createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true)
get: createInstrumentationGetter(true, false)
};

@@ -630,12 +676,26 @@ function checkIdentityKeys(target, has, key) {

const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);
const isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');
const canObserve = (value) => {
return (!value.__v_skip &&
isObservableType(toRawType(value)) &&
!Object.isFrozen(value));
};
const reactiveMap = new WeakMap();
const readonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case 'Object':
case 'Array':
return 1 /* COMMON */;
case 'Map':
case 'Set':
case 'WeakMap':
case 'WeakSet':
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
? 0 /* INVALID */
: targetTypeMap(toRawType(value));
}
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target.__v_isReadonly) {
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
return target;

@@ -649,3 +709,3 @@ }

function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, mutableCollectionHandlers);
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
}

@@ -671,25 +731,29 @@ function readonly(target) {

// exception: calling readonly() on a reactive object
if (target.__v_raw && !(isReadonly && target.__v_isReactive)) {
if (target["__v_raw" /* RAW */] &&
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
return target;
}
// target already has corresponding Proxy
if (hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) {
return isReadonly ? target.__v_readonly : target.__v_reactive;
const proxyMap = isReadonly ? readonlyMap : reactiveMap;
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
// only a whitelist of value types can be observed.
if (!canObserve(target)) {
const targetType = getTargetType(target);
if (targetType === 0 /* INVALID */) {
return target;
}
const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed);
return observed;
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value.__v_raw);
return isReactive(value["__v_raw" /* RAW */]);
}
return !!(value && value.__v_isReactive);
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
}
function isReadonly(value) {
return !!(value && value.__v_isReadonly);
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
}

@@ -700,6 +764,6 @@ function isProxy(value) {

function toRaw(observed) {
return (observed && toRaw(observed.__v_raw)) || observed;
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
}
function markRaw(value) {
def(value, "__v_skip" /* skip */, true);
def(value, "__v_skip" /* SKIP */, true);
return value;

@@ -710,3 +774,3 @@ }

function isRef(r) {
return r ? r.__v_isRef === true : false;
return Boolean(r && r.__v_isRef === true);
}

@@ -719,2 +783,21 @@ function ref(value) {

}
class RefImpl {
constructor(_rawValue, _shallow = false) {
this._rawValue = _rawValue;
this._shallow = _shallow;
this.__v_isRef = true;
this._value = _shallow ? _rawValue : convert(_rawValue);
}
get value() {
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newVal) {
if (hasChanged(toRaw(newVal), this._rawValue)) {
this._rawValue = newVal;
this._value = this._shallow ? newVal : convert(newVal);
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
}
}
}
function createRef(rawValue, shallow = false) {

@@ -724,21 +807,6 @@ if (isRef(rawValue)) {

}
let value = shallow ? rawValue : convert(rawValue);
const r = {
__v_isRef: true,
get value() {
track(r, "get" /* GET */, 'value');
return value;
},
set value(newVal) {
if (hasChanged(toRaw(newVal), rawValue)) {
rawValue = newVal;
value = shallow ? newVal : convert(newVal);
trigger(r, "set" /* SET */, 'value', { newValue: newVal } );
}
}
};
return r;
return new RefImpl(rawValue, shallow);
}
function triggerRef(ref) {
trigger(ref, "set" /* SET */, 'value', { newValue: ref.value } );
trigger(ref, "set" /* SET */, 'value', ref.value );
}

@@ -748,15 +816,37 @@ function unref(ref) {

}
function customRef(factory) {
const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value'));
const r = {
__v_isRef: true,
get value() {
return get();
},
set value(v) {
set(v);
const shallowUnwrapHandlers = {
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
};
return r;
else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs)
? objectWithRefs
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this.__v_isRef = true;
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
this._get = get;
this._set = set;
}
get value() {
return this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {

@@ -766,3 +856,3 @@ if ( !isProxy(object)) {

}
const ret = {};
const ret = isArray(object) ? new Array(object.length) : {};
for (const key in object) {

@@ -773,14 +863,49 @@ ret[key] = toRef(object, key);

}
class ObjectRefImpl {
constructor(_object, _key) {
this._object = _object;
this._key = _key;
this.__v_isRef = true;
}
get value() {
return this._object[this._key];
}
set value(newVal) {
this._object[this._key] = newVal;
}
}
function toRef(object, key) {
return {
__v_isRef: true,
get value() {
return object[key];
},
set value(newVal) {
object[key] = newVal;
return isRef(object[key])
? object[key]
: new ObjectRefImpl(object, key);
}
class ComputedRefImpl {
constructor(getter, _setter, isReadonly) {
this._setter = _setter;
this._dirty = true;
this.__v_isRef = true;
this.effect = effect(getter, {
lazy: true,
scheduler: () => {
if (!this._dirty) {
this._dirty = true;
trigger(toRaw(this), "set" /* SET */, 'value');
}
}
});
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
}
get value() {
if (this._dirty) {
this._value = this.effect();
this._dirty = false;
}
};
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newValue) {
this._setter(newValue);
}
}
function computed(getterOrOptions) {

@@ -800,33 +925,3 @@ let getter;

}
let dirty = true;
let value;
let computed;
const runner = effect(getter, {
lazy: true,
// mark effect as computed so that it gets priority during trigger
computed: true,
scheduler: () => {
if (!dirty) {
dirty = true;
trigger(computed, "set" /* SET */, 'value');
}
}
});
computed = {
__v_isRef: true,
// expose effect so computed can be stopped
effect: runner,
get value() {
if (dirty) {
value = runner();
dirty = false;
}
track(computed, "get" /* GET */, 'value');
return value;
},
set value(newValue) {
setter(newValue);
}
};
return computed;
return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
}

@@ -845,2 +940,3 @@

exports.pauseTracking = pauseTracking;
exports.proxyRefs = proxyRefs;
exports.reactive = reactive;

@@ -847,0 +943,0 @@ exports.readonly = readonly;

+1
-1
dist/reactivity.global.prod.js

@@ -1,1 +0,1 @@

var VueReactivity=function(e){"use strict";function t(e,t){const n=Object.create(null),r=e.split(",");for(let e=0;e<r.length;e++)n[r[e]]=!0;return t?e=>!!n[e.toLowerCase()]:e=>!!n[e]}const n={},r=()=>{},o=Object.prototype.hasOwnProperty,c=(e,t)=>o.call(e,t),i=Array.isArray,s=e=>"symbol"==typeof e,u=e=>null!==e&&"object"==typeof e,a=Object.prototype.toString,l=e=>(e=>a.call(e))(e).slice(8,-1),f=(e,t)=>e!==t&&(e==e||t==t),_=(e,t,n)=>{Object.defineProperty(e,t,{configurable:!0,value:n})},v=new WeakMap,d=[];let h;const p=Symbol(""),g=Symbol("");function y(e,t=n){(function(e){return e&&!0===e._isEffect})(e)&&(e=e.raw);const r=function(e,t){const n=function(...r){if(!n.active)return t.scheduler?void 0:e(...r);if(!d.includes(n)){w(n);try{return m(),d.push(n),h=n,e(...r)}finally{d.pop(),E(),h=d[d.length-1]}}};return n.id=R++,n._isEffect=!0,n.active=!0,n.raw=e,n.deps=[],n.options=t,n}(e,t);return t.lazy||r(),r}let R=0;function w(e){const{deps:t}=e;if(t.length){for(let n=0;n<t.length;n++)t[n].delete(e);t.length=0}}let S=!0;const b=[];function m(){b.push(S),S=!0}function E(){const e=b.pop();S=void 0===e||e}function k(e,t,n){if(!S||void 0===h)return;let r=v.get(e);r||v.set(e,r=new Map);let o=r.get(n);o||r.set(n,o=new Set),o.has(h)||(o.add(h),h.deps.push(o))}function O(e,t,n,r,o,c){const s=v.get(e);if(!s)return;const u=new Set,a=new Set,l=e=>{e&&e.forEach(e=>{e===h&&S||(e.options.computed?a.add(e):u.add(e))})};if("clear"===t)s.forEach(l);else if("length"===n&&i(e))s.forEach((e,t)=>{("length"===t||t>=r)&&l(e)});else{void 0!==n&&l(s.get(n));const r="add"===t||"delete"===t&&!i(e);(r||"set"===t&&e instanceof Map)&&l(s.get(i(e)?"length":p)),r&&e instanceof Map&&l(s.get(g))}const f=e=>{e.options.scheduler?e.options.scheduler(e):e()};a.forEach(f),u.forEach(f)}const M=new Set(Object.getOwnPropertyNames(Symbol).map(e=>Symbol[e]).filter(s)),P=W(),j=W(!1,!0),z=W(!0),x=W(!0,!0),T={};function W(e=!1,t=!1){return function(n,r,o){if("__v_isReactive"===r)return!e;if("__v_isReadonly"===r)return e;if("__v_raw"===r||"__proto__"===r)return n;const a=i(n);if(a&&c(T,r))return Reflect.get(T,r,o);const l=Reflect.get(n,r,o);return s(r)&&M.has(r)?l:t?(!e&&k(n,0,r),l):_e(l)?a?(!e&&k(n,0,r),l):l.value:(!e&&k(n,0,r),u(l)?e?ie(l):ce(l):l)}}["includes","indexOf","lastIndexOf"].forEach(e=>{T[e]=function(...t){const n=le(this);for(let e=0,t=this.length;e<t;e++)k(n,0,e+"");const r=n[e](...t);return-1===r||!1===r?n[e](...t.map(le)):r}});const A=I(),K=I(!0);function I(e=!1){return function(t,n,r,o){const s=t[n];if(!e&&(r=le(r),!i(t)&&_e(s)&&!_e(r)))return s.value=r,!0;const u=c(t,n),a=Reflect.set(t,n,r,o);return t===le(o)&&(u?f(r,s)&&O(t,"set",n,r):O(t,"add",n,r)),a}}function C(e,t){const n=Reflect.has(e,t);return k(e,0,t),n}function F(e){return k(e,0,p),Reflect.ownKeys(e)}const L={get:P,set:A,deleteProperty:function(e,t){const n=c(e,t),r=Reflect.deleteProperty(e,t);return r&&n&&O(e,"delete",t,void 0),r},has:C,ownKeys:F},N={get:z,has:C,ownKeys:F,set:(e,t)=>!0,deleteProperty:(e,t)=>!0},V={...L,get:j,set:K},Y={...N,get:x},q=e=>u(e)?ce(e):e,B=e=>u(e)?ie(e):e,D=e=>Reflect.getPrototypeOf(e);function G(e,t,n){e=le(e);const r=le(t);t!==r&&k(e,0,t),k(e,0,r);const{has:o,get:c}=D(e);return o.call(e,t)?n(c.call(e,t)):o.call(e,r)?n(c.call(e,r)):void 0}function H(e){const t=le(this),n=le(e);e!==n&&k(t,0,e),k(t,0,n);const r=D(t).has;return r.call(t,e)||r.call(t,n)}function J(e){return k(e=le(e),0,p),Reflect.get(D(e),"size",e)}function Q(e){return function(t,n){const r=this,o=le(r),c=e?B:q;return!e&&k(o,0,p),D(o).forEach.call(o,(function(e,n){return t.call(r,c(e),c(n),r)}),n)}}function U(e,t){return function(...n){const r=le(this),o=r instanceof Map,c="entries"===e||e===Symbol.iterator&&o,i="keys"===e&&o,s=D(r)[e].apply(r,n),u=t?B:q;return!t&&k(r,0,i?g:p),{next(){const{value:e,done:t}=s.next();return t?{value:e,done:t}:{value:c?[u(e[0]),u(e[1])]:u(e),done:t}},[Symbol.iterator](){return this}}}}function X(e){return function(...t){return"delete"!==e&&this}}const Z={get(e){return G(this,e,q)},get size(){return J(this)},has:H,add:function(e){e=le(e);const t=le(this),n=D(t),r=n.has.call(t,e),o=n.add.call(t,e);return r||O(t,"add",e,e),o},set:function(e,t){t=le(t);const n=le(this),{has:r,get:o,set:c}=D(n);let i=r.call(n,e);i||(e=le(e),i=r.call(n,e));const s=o.call(n,e),u=c.call(n,e,t);return i?f(t,s)&&O(n,"set",e,t):O(n,"add",e,t),u},delete:function(e){const t=le(this),{has:n,get:r,delete:o}=D(t);let c=n.call(t,e);c||(e=le(e),c=n.call(t,e)),r&&r.call(t,e);const i=o.call(t,e);return c&&O(t,"delete",e,void 0),i},clear:function(){const e=le(this),t=0!==e.size,n=D(e).clear.call(e);return t&&O(e,"clear",void 0,void 0),n},forEach:Q(!1)},$={get(e){return G(this,e,B)},get size(){return J(this)},has:H,add:X("add"),set:X("set"),delete:X("delete"),clear:X("clear"),forEach:Q(!0)};function ee(e){const t=e?$:Z;return(n,r,o)=>"__v_isReactive"===r?!e:"__v_isReadonly"===r?e:"__v_raw"===r?n:Reflect.get(c(t,r)&&r in n?t:n,r,o)}["keys","values","entries",Symbol.iterator].forEach(e=>{Z[e]=U(e,!1),$[e]=U(e,!0)});const te={get:ee(!1)},ne={get:ee(!0)},re=new Set([Set,Map,WeakMap,WeakSet]),oe=t("Object,Array,Map,Set,WeakMap,WeakSet");function ce(e){return e&&e.__v_isReadonly?e:se(e,!1,L,te)}function ie(e){return se(e,!0,N,ne)}function se(e,t,n,r){if(!u(e))return e;if(e.__v_raw&&(!t||!e.__v_isReactive))return e;if(c(e,t?"__v_readonly":"__v_reactive"))return t?e.__v_readonly:e.__v_reactive;if((o=e).__v_skip||!oe(l(o))||Object.isFrozen(o))return e;var o;const i=new Proxy(e,re.has(e.constructor)?r:n);return _(e,t?"__v_readonly":"__v_reactive",i),i}function ue(e){return ae(e)?ue(e.__v_raw):!(!e||!e.__v_isReactive)}function ae(e){return!(!e||!e.__v_isReadonly)}function le(e){return e&&le(e.__v_raw)||e}const fe=e=>u(e)?ce(e):e;function _e(e){return!!e&&!0===e.__v_isRef}function ve(e,t=!1){if(_e(e))return e;let n=t?e:fe(e);const r={__v_isRef:!0,get value(){return k(r,0,"value"),n},set value(o){f(le(o),e)&&(e=o,n=t?o:fe(o),O(r,"set","value",void 0))}};return r}function de(e,t){return{__v_isRef:!0,get value(){return e[t]},set value(n){e[t]=n}}}return e.ITERATE_KEY=p,e.computed=function(e){let t,n;"function"==typeof e?(t=e,n=r):(t=e.get,n=e.set);let o,c,i=!0;const s=y(t,{lazy:!0,computed:!0,scheduler:()=>{i||(i=!0,O(c,"set","value"))}});return c={__v_isRef:!0,effect:s,get value(){return i&&(o=s(),i=!1),k(c,0,"value"),o},set value(e){n(e)}},c},e.customRef=function(e){const{get:t,set:n}=e(()=>k(r,0,"value"),()=>O(r,"set","value")),r={__v_isRef:!0,get value(){return t()},set value(e){n(e)}};return r},e.effect=y,e.enableTracking=m,e.isProxy=function(e){return ue(e)||ae(e)},e.isReactive=ue,e.isReadonly=ae,e.isRef=_e,e.markRaw=function(e){return _(e,"__v_skip",!0),e},e.pauseTracking=function(){b.push(S),S=!1},e.reactive=ce,e.readonly=ie,e.ref=function(e){return ve(e)},e.resetTracking=E,e.shallowReactive=function(e){return se(e,!1,V,te)},e.shallowReadonly=function(e){return se(e,!0,Y,ne)},e.shallowRef=function(e){return ve(e,!0)},e.stop=function(e){e.active&&(w(e),e.options.onStop&&e.options.onStop(),e.active=!1)},e.toRaw=le,e.toRef=de,e.toRefs=function(e){const t={};for(const n in e)t[n]=de(e,n);return t},e.track=k,e.trigger=O,e.triggerRef=function(e){O(e,"set","value",void 0)},e.unref=function(e){return _e(e)?e.value:e},e}({});
var VueReactivity=function(t){"use strict";const e={},n=()=>{},r=Object.assign,s=Object.prototype.hasOwnProperty,i=(t,e)=>s.call(t,e),o=Array.isArray,c=t=>"[object Map]"===_(t),u=t=>"function"==typeof t,a=t=>"symbol"==typeof t,l=t=>null!==t&&"object"==typeof t,f=Object.prototype.toString,_=t=>f.call(t),h=t=>"string"==typeof t&&"NaN"!==t&&"-"!==t[0]&&""+parseInt(t,10)===t,v=(t,e)=>t!==e&&(t==t||e==e),d=new WeakMap,g=[];let p;const y=Symbol(""),w=Symbol("");function R(t,n=e){(function(t){return t&&!0===t._isEffect})(t)&&(t=t.raw);const r=function(t,e){const n=function(){if(!n.active)return e.scheduler?void 0:t();if(!g.includes(n)){k(n);try{return j(),g.push(n),p=n,t()}finally{g.pop(),O(),p=g[g.length-1]}}};return n.id=b++,n._isEffect=!0,n.active=!0,n.raw=t,n.deps=[],n.options=e,n}(t,n);return n.lazy||r(),r}let b=0;function k(t){const{deps:e}=t;if(e.length){for(let n=0;n<e.length;n++)e[n].delete(t);e.length=0}}let E=!0;const m=[];function S(){m.push(E),E=!1}function j(){m.push(E),E=!0}function O(){const t=m.pop();E=void 0===t||t}function P(t,e,n){if(!E||void 0===p)return;let r=d.get(t);r||d.set(t,r=new Map);let s=r.get(n);s||r.set(n,s=new Set),s.has(p)||(s.add(p),p.deps.push(s))}function x(t,e,n,r,s,i){const u=d.get(t);if(!u)return;const a=new Set,l=t=>{t&&t.forEach(t=>{(t!==p||t.options.allowRecurse)&&a.add(t)})};if("clear"===e)u.forEach(l);else if("length"===n&&o(t))u.forEach((t,e)=>{("length"===e||e>=r)&&l(t)});else switch(void 0!==n&&l(u.get(n)),e){case"add":o(t)?h(n)&&l(u.get("length")):(l(u.get(y)),c(t)&&l(u.get(w)));break;case"delete":o(t)||(l(u.get(y)),c(t)&&l(u.get(w)));break;case"set":c(t)&&l(u.get(y))}a.forEach(t=>{t.options.scheduler?t.options.scheduler(t):t()})}const z=new Set(Object.getOwnPropertyNames(Symbol).map(t=>Symbol[t]).filter(a)),A=V(),M=V(!1,!0),T=V(!0),W=V(!0,!0),N={};function V(t=!1,e=!1){return function(n,r,s){if("__v_isReactive"===r)return!t;if("__v_isReadonly"===r)return t;if("__v_raw"===r&&s===(t?lt:at).get(n))return n;const c=o(n);if(c&&i(N,r))return Reflect.get(N,r,s);const u=Reflect.get(n,r,s);if(a(r)?z.has(r):"__proto__"===r||"__v_isRef"===r)return u;if(t||P(n,0,r),e)return u;if(wt(u)){return!c||!h(r)?u.value:u}return l(u)?t?ht(u):_t(u):u}}["includes","indexOf","lastIndexOf"].forEach(t=>{const e=Array.prototype[t];N[t]=function(...t){const n=pt(this);for(let t=0,e=this.length;t<e;t++)P(n,0,t+"");const r=e.apply(n,t);return-1===r||!1===r?e.apply(n,t.map(pt)):r}}),["push","pop","shift","unshift","splice"].forEach(t=>{const e=Array.prototype[t];N[t]=function(...t){S();const n=e.apply(this,t);return j(),n}});function I(t=!1){return function(e,n,r,s){const c=e[n];if(!t&&(r=pt(r),!o(e)&&wt(c)&&!wt(r)))return c.value=r,!0;const u=o(e)&&h(n)?Number(n)<e.length:i(e,n),a=Reflect.set(e,n,r,s);return e===pt(s)&&(u?v(r,c)&&x(e,"set",n,r):x(e,"add",n,r)),a}}const K={get:A,set:I(),deleteProperty:function(t,e){const n=i(t,e),r=Reflect.deleteProperty(t,e);return r&&n&&x(t,"delete",e,void 0),r},has:function(t,e){const n=Reflect.has(t,e);return a(e)&&z.has(e)||P(t,0,e),n},ownKeys:function(t){return P(t,0,y),Reflect.ownKeys(t)}},B={get:T,set:(t,e)=>!0,deleteProperty:(t,e)=>!0},Y=r({},K,{get:M,set:I(!0)}),q=r({},B,{get:W}),C=t=>l(t)?_t(t):t,D=t=>l(t)?ht(t):t,F=t=>t,G=t=>Reflect.getPrototypeOf(t);function H(t,e,n=!1,r=!1){const s=pt(t=t.__v_raw),i=pt(e);e!==i&&!n&&P(s,0,e),!n&&P(s,0,i);const{has:o}=G(s),c=n?D:r?F:C;return o.call(s,e)?c(t.get(e)):o.call(s,i)?c(t.get(i)):void 0}function J(t,e=!1){const n=this.__v_raw,r=pt(n),s=pt(t);return t!==s&&!e&&P(r,0,t),!e&&P(r,0,s),t===s?n.has(t):n.has(t)||n.has(s)}function L(t,e=!1){return t=t.__v_raw,!e&&P(pt(t),0,y),Reflect.get(t,"size",t)}function Q(t){t=pt(t);const e=pt(this),n=G(e).has.call(e,t),r=e.add(t);return n||x(e,"add",t,t),r}function U(t,e){e=pt(e);const n=pt(this),{has:r,get:s}=G(n);let i=r.call(n,t);i||(t=pt(t),i=r.call(n,t));const o=s.call(n,t),c=n.set(t,e);return i?v(e,o)&&x(n,"set",t,e):x(n,"add",t,e),c}function X(t){const e=pt(this),{has:n,get:r}=G(e);let s=n.call(e,t);s||(t=pt(t),s=n.call(e,t));r&&r.call(e,t);const i=e.delete(t);return s&&x(e,"delete",t,void 0),i}function Z(){const t=pt(this),e=0!==t.size,n=t.clear();return e&&x(t,"clear",void 0,void 0),n}function $(t,e){return function(n,r){const s=this,i=s.__v_raw,o=pt(i),c=t?D:e?F:C;return!t&&P(o,0,y),i.forEach((t,e)=>n.call(r,c(t),c(e),s))}}function tt(t,e,n){return function(...r){const s=this.__v_raw,i=pt(s),o=c(i),u="entries"===t||t===Symbol.iterator&&o,a="keys"===t&&o,l=s[t](...r),f=e?D:n?F:C;return!e&&P(i,0,a?w:y),{next(){const{value:t,done:e}=l.next();return e?{value:t,done:e}:{value:u?[f(t[0]),f(t[1])]:f(t),done:e}},[Symbol.iterator](){return this}}}}function et(t){return function(...e){return"delete"!==t&&this}}const nt={get(t){return H(this,t)},get size(){return L(this)},has:J,add:Q,set:U,delete:X,clear:Z,forEach:$(!1,!1)},rt={get(t){return H(this,t,!1,!0)},get size(){return L(this)},has:J,add:Q,set:U,delete:X,clear:Z,forEach:$(!1,!0)},st={get(t){return H(this,t,!0)},get size(){return L(this,!0)},has(t){return J.call(this,t,!0)},add:et("add"),set:et("set"),delete:et("delete"),clear:et("clear"),forEach:$(!0,!1)};function it(t,e){const n=e?rt:t?st:nt;return(e,r,s)=>"__v_isReactive"===r?!t:"__v_isReadonly"===r?t:"__v_raw"===r?e:Reflect.get(i(n,r)&&r in e?n:e,r,s)}["keys","values","entries",Symbol.iterator].forEach(t=>{nt[t]=tt(t,!1,!1),st[t]=tt(t,!0,!1),rt[t]=tt(t,!1,!0)});const ot={get:it(!1,!1)},ct={get:it(!1,!0)},ut={get:it(!0,!1)},at=new WeakMap,lt=new WeakMap;function ft(t){return t.__v_skip||!Object.isExtensible(t)?0:function(t){switch(t){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}((t=>_(t).slice(8,-1))(t))}function _t(t){return t&&t.__v_isReadonly?t:vt(t,!1,K,ot)}function ht(t){return vt(t,!0,B,ut)}function vt(t,e,n,r){if(!l(t))return t;if(t.__v_raw&&(!e||!t.__v_isReactive))return t;const s=e?lt:at,i=s.get(t);if(i)return i;const o=ft(t);if(0===o)return t;const c=new Proxy(t,2===o?r:n);return s.set(t,c),c}function dt(t){return gt(t)?dt(t.__v_raw):!(!t||!t.__v_isReactive)}function gt(t){return!(!t||!t.__v_isReadonly)}function pt(t){return t&&pt(t.__v_raw)||t}const yt=t=>l(t)?_t(t):t;function wt(t){return Boolean(t&&!0===t.__v_isRef)}class Rt{constructor(t,e=!1){this._rawValue=t,this._shallow=e,this.__v_isRef=!0,this._value=e?t:yt(t)}get value(){return P(pt(this),0,"value"),this._value}set value(t){v(pt(t),this._rawValue)&&(this._rawValue=t,this._value=this._shallow?t:yt(t),x(pt(this),"set","value",t))}}function bt(t,e=!1){return wt(t)?t:new Rt(t,e)}function kt(t){return wt(t)?t.value:t}const Et={get:(t,e,n)=>kt(Reflect.get(t,e,n)),set:(t,e,n,r)=>{const s=t[e];return wt(s)&&!wt(n)?(s.value=n,!0):Reflect.set(t,e,n,r)}};class mt{constructor(t){this.__v_isRef=!0;const{get:e,set:n}=t(()=>P(this,0,"value"),()=>x(this,"set","value"));this._get=e,this._set=n}get value(){return this._get()}set value(t){this._set(t)}}class St{constructor(t,e){this._object=t,this._key=e,this.__v_isRef=!0}get value(){return this._object[this._key]}set value(t){this._object[this._key]=t}}function jt(t,e){return wt(t[e])?t[e]:new St(t,e)}class Ot{constructor(t,e,n){this._setter=e,this._dirty=!0,this.__v_isRef=!0,this.effect=R(t,{lazy:!0,scheduler:()=>{this._dirty||(this._dirty=!0,x(pt(this),"set","value"))}}),this.__v_isReadonly=n}get value(){return this._dirty&&(this._value=this.effect(),this._dirty=!1),P(pt(this),0,"value"),this._value}set value(t){this._setter(t)}}return t.ITERATE_KEY=y,t.computed=function(t){let e,r;return u(t)?(e=t,r=n):(e=t.get,r=t.set),new Ot(e,r,u(t)||!t.set)},t.customRef=function(t){return new mt(t)},t.effect=R,t.enableTracking=j,t.isProxy=function(t){return dt(t)||gt(t)},t.isReactive=dt,t.isReadonly=gt,t.isRef=wt,t.markRaw=function(t){return((t,e,n)=>{Object.defineProperty(t,e,{configurable:!0,enumerable:!1,value:n})})(t,"__v_skip",!0),t},t.pauseTracking=S,t.proxyRefs=function(t){return dt(t)?t:new Proxy(t,Et)},t.reactive=_t,t.readonly=ht,t.ref=function(t){return bt(t)},t.resetTracking=O,t.shallowReactive=function(t){return vt(t,!1,Y,ct)},t.shallowReadonly=function(t){return vt(t,!0,q,ut)},t.shallowRef=function(t){return bt(t,!0)},t.stop=function(t){t.active&&(k(t),t.options.onStop&&t.options.onStop(),t.active=!1)},t.toRaw=pt,t.toRef=jt,t.toRefs=function(t){const e=o(t)?new Array(t.length):{};for(const n in t)e[n]=jt(t,n);return e},t.track=P,t.trigger=x,t.triggerRef=function(t){x(t,"set","value",void 0)},t.unref=kt,t}({});
+4
-3
package.json
{
"name": "@atom-vue/reactivity",
"version": "3.0.1-alpha.1",
"version": "3.0.1-beta.0",
"description": "@vue/reactivity",

@@ -17,3 +17,4 @@ "main": "index.js",

"type": "git",
"url": "git+https://github.com/vuejs/vue-next.git"
"url": "git+https://github.com/vuejs/vue-next.git",
"directory": "packages/reactivity"
},

@@ -39,4 +40,4 @@ "buildOptions": {

"dependencies": {
"@atom-vue/shared": "3.0.1-alpha.1"
"@atom-vue/shared": "3.0.1-beta.0"
}
}