+++ /dev/null
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
- module.exports = require('./dist/observer.cjs.prod.js')
-} else {
- module.exports = require('./dist/observer.cjs.js')
-}
-import { observable, effect, unwrap, isObservable } from '../../src'
+import { state, effect, toRaw, isState } from '../../src'
describe('observer/collections', () => {
describe('Map', () => {
test('instanceof', () => {
const original = new Map()
- const observed = observable(original)
- expect(isObservable(observed)).toBe(true)
+ const observed = state(original)
+ expect(isState(observed)).toBe(true)
expect(original instanceof Map).toBe(true)
expect(observed instanceof Map).toBe(true)
})
it('should observe mutations', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => {
dummy = map.get('key')
})
it('should observe size mutations', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => (dummy = map.size))
expect(dummy).toBe(0)
it('should observe for of iteration', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => {
dummy = 0
// eslint-disable-next-line no-unused-vars
it('should observe forEach iteration', () => {
let dummy: any
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => {
dummy = 0
map.forEach((num: any) => (dummy += num))
it('should observe keys iteration', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => {
dummy = 0
for (let key of map.keys()) {
it('should observe values iteration', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => {
dummy = 0
for (let num of map.values()) {
it('should observe entries iteration', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => {
dummy = 0
// eslint-disable-next-line no-unused-vars
it('should be triggered by clearing', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
effect(() => (dummy = map.get('key')))
expect(dummy).toBe(undefined)
it('should not observe custom property mutations', () => {
let dummy
- const map: any = observable(new Map())
+ const map: any = state(new Map())
effect(() => (dummy = map.customProp))
expect(dummy).toBe(undefined)
it('should not observe non value changing mutations', () => {
let dummy
- const map = observable(new Map())
+ const map = state(new Map())
const mapSpy = jest.fn(() => (dummy = map.get('key')))
effect(mapSpy)
it('should not observe raw data', () => {
let dummy
- const map = observable(new Map())
- effect(() => (dummy = unwrap(map).get('key')))
+ const map = state(new Map())
+ effect(() => (dummy = toRaw(map).get('key')))
expect(dummy).toBe(undefined)
map.set('key', 'Hello')
it('should not pollute original Map with Proxies', () => {
const map = new Map()
- const observed = observable(map)
- const value = observable({})
+ const observed = state(map)
+ const value = state({})
observed.set('key', value)
expect(map.get('key')).not.toBe(value)
- expect(map.get('key')).toBe(unwrap(value))
+ expect(map.get('key')).toBe(toRaw(value))
})
it('should return observable versions of contained values', () => {
- const observed = observable(new Map())
+ const observed = state(new Map())
const value = {}
observed.set('key', value)
const wrapped = observed.get('key')
- expect(isObservable(wrapped)).toBe(true)
- expect(unwrap(wrapped)).toBe(value)
+ expect(isState(wrapped)).toBe(true)
+ expect(toRaw(wrapped)).toBe(value)
})
it('should observed nested data', () => {
- const observed = observable(new Map())
+ const observed = state(new Map())
observed.set('key', { a: 1 })
let dummy
effect(() => {
})
it('should observe nested values in iterations (forEach)', () => {
- const map = observable(new Map([[1, { foo: 1 }]]))
+ const map = state(new Map([[1, { foo: 1 }]]))
let dummy: any
effect(() => {
dummy = 0
map.forEach(value => {
- expect(isObservable(value)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
})
})
})
it('should observe nested values in iterations (values)', () => {
- const map = observable(new Map([[1, { foo: 1 }]]))
+ const map = state(new Map([[1, { foo: 1 }]]))
let dummy: any
effect(() => {
dummy = 0
for (const value of map.values()) {
- expect(isObservable(value)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
}
})
it('should observe nested values in iterations (entries)', () => {
const key = {}
- const map = observable(new Map([[key, { foo: 1 }]]))
+ const map = state(new Map([[key, { foo: 1 }]]))
let dummy: any
effect(() => {
dummy = 0
for (const [key, value] of map.entries()) {
key
- expect(isObservable(key)).toBe(true)
- expect(isObservable(value)).toBe(true)
+ expect(isState(key)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
}
})
it('should observe nested values in iterations (for...of)', () => {
const key = {}
- const map = observable(new Map([[key, { foo: 1 }]]))
+ const map = state(new Map([[key, { foo: 1 }]]))
let dummy: any
effect(() => {
dummy = 0
for (const [key, value] of map) {
key
- expect(isObservable(key)).toBe(true)
- expect(isObservable(value)).toBe(true)
+ expect(isState(key)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
}
})
-import { observable, effect, isObservable, unwrap } from '../../src'
+import { state, effect, isState, toRaw } from '../../src'
describe('observer/collections', () => {
describe('Set', () => {
it('instanceof', () => {
const original = new Set()
- const observed = observable(original)
- expect(isObservable(observed)).toBe(true)
+ const observed = state(original)
+ expect(isState(observed)).toBe(true)
expect(original instanceof Set).toBe(true)
expect(observed instanceof Set).toBe(true)
})
it('should observe mutations', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set())
effect(() => (dummy = set.has('value')))
expect(dummy).toBe(false)
it('should observe for of iteration', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set() as Set<number>)
effect(() => {
dummy = 0
for (let num of set) {
it('should observe forEach iteration', () => {
let dummy: any
- const set = observable(new Set())
+ const set = state(new Set())
effect(() => {
dummy = 0
set.forEach(num => (dummy += num))
it('should observe values iteration', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set() as Set<number>)
effect(() => {
dummy = 0
for (let num of set.values()) {
it('should observe keys iteration', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set() as Set<number>)
effect(() => {
dummy = 0
for (let num of set.keys()) {
it('should observe entries iteration', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set() as Set<number>)
effect(() => {
dummy = 0
// eslint-disable-next-line no-unused-vars
it('should be triggered by clearing', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set())
effect(() => (dummy = set.has('key')))
expect(dummy).toBe(false)
it('should not observe custom property mutations', () => {
let dummy
- const set: any = observable(new Set())
+ const set: any = state(new Set())
effect(() => (dummy = set.customProp))
expect(dummy).toBe(undefined)
it('should observe size mutations', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set())
effect(() => (dummy = set.size))
expect(dummy).toBe(0)
it('should not observe non value changing mutations', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set())
const setSpy = jest.fn(() => (dummy = set.has('value')))
effect(setSpy)
it('should not observe raw data', () => {
let dummy
- const set = observable(new Set())
- effect(() => (dummy = unwrap(set).has('value')))
+ const set = state(new Set())
+ effect(() => (dummy = toRaw(set).has('value')))
expect(dummy).toBe(false)
set.add('value')
it('should not observe raw iterations', () => {
let dummy = 0
- const set = observable(new Set())
+ const set = state(new Set() as Set<number>)
effect(() => {
dummy = 0
- for (let [num] of unwrap(set).entries()) {
+ for (let [num] of toRaw(set).entries()) {
dummy += num
}
- for (let num of unwrap(set).keys()) {
+ for (let num of toRaw(set).keys()) {
dummy += num
}
- for (let num of unwrap(set).values()) {
+ for (let num of toRaw(set).values()) {
dummy += num
}
- unwrap(set).forEach(num => {
+ toRaw(set).forEach(num => {
dummy += num
})
- for (let num of unwrap(set)) {
+ for (let num of toRaw(set)) {
dummy += num
}
})
it('should not be triggered by raw mutations', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set())
effect(() => (dummy = set.has('value')))
expect(dummy).toBe(false)
- unwrap(set).add('value')
+ toRaw(set).add('value')
expect(dummy).toBe(false)
dummy = true
- unwrap(set).delete('value')
+ toRaw(set).delete('value')
expect(dummy).toBe(true)
- unwrap(set).clear()
+ toRaw(set).clear()
expect(dummy).toBe(true)
})
it('should not observe raw size mutations', () => {
let dummy
- const set = observable(new Set())
- effect(() => (dummy = unwrap(set).size))
+ const set = state(new Set())
+ effect(() => (dummy = toRaw(set).size))
expect(dummy).toBe(0)
set.add('value')
it('should not be triggered by raw size mutations', () => {
let dummy
- const set = observable(new Set())
+ const set = state(new Set())
effect(() => (dummy = set.size))
expect(dummy).toBe(0)
- unwrap(set).add('value')
+ toRaw(set).add('value')
expect(dummy).toBe(0)
})
it('should support objects as key', () => {
let dummy
const key = {}
- const set = observable(new Set())
+ const set = state(new Set())
const setSpy = jest.fn(() => (dummy = set.has(key)))
effect(setSpy)
it('should not pollute original Set with Proxies', () => {
const set = new Set()
- const observed = observable(set)
- const value = observable({})
+ const observed = state(set)
+ const value = state({})
observed.add(value)
expect(observed.has(value)).toBe(true)
expect(set.has(value)).toBe(false)
})
it('should observe nested values in iterations (forEach)', () => {
- const set = observable(new Set([{ foo: 1 }]))
+ const set = state(new Set([{ foo: 1 }]))
let dummy: any
effect(() => {
dummy = 0
set.forEach(value => {
- expect(isObservable(value)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
})
})
})
it('should observe nested values in iterations (values)', () => {
- const set = observable(new Set([{ foo: 1 }]))
+ const set = state(new Set([{ foo: 1 }]))
let dummy: any
effect(() => {
dummy = 0
for (const value of set.values()) {
- expect(isObservable(value)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
}
})
})
it('should observe nested values in iterations (entries)', () => {
- const set = observable(new Set([{ foo: 1 }]))
+ const set = state(new Set([{ foo: 1 }]))
let dummy: any
effect(() => {
dummy = 0
for (const [key, value] of set.entries()) {
- expect(isObservable(key)).toBe(true)
- expect(isObservable(value)).toBe(true)
+ expect(isState(key)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
}
})
})
it('should observe nested values in iterations (for...of)', () => {
- const set = observable(new Set([{ foo: 1 }]))
+ const set = state(new Set([{ foo: 1 }]))
let dummy: any
effect(() => {
dummy = 0
for (const value of set) {
- expect(isObservable(value)).toBe(true)
+ expect(isState(value)).toBe(true)
dummy += value.foo
}
})
-import { observable, effect, unwrap, isObservable } from '../../src'
+import { state, effect, toRaw, isState } from '../../src'
describe('observer/collections', () => {
describe('WeakMap', () => {
test('instanceof', () => {
const original = new WeakMap()
- const observed = observable(original)
- expect(isObservable(observed)).toBe(true)
+ const observed = state(original)
+ expect(isState(observed)).toBe(true)
expect(original instanceof WeakMap).toBe(true)
expect(observed instanceof WeakMap).toBe(true)
})
it('should observe mutations', () => {
let dummy
const key = {}
- const map = observable(new WeakMap())
+ const map = state(new WeakMap())
effect(() => {
dummy = map.get(key)
})
it('should not observe custom property mutations', () => {
let dummy
- const map: any = observable(new WeakMap())
+ const map: any = state(new WeakMap())
effect(() => (dummy = map.customProp))
expect(dummy).toBe(undefined)
it('should not observe non value changing mutations', () => {
let dummy
const key = {}
- const map = observable(new WeakMap())
+ const map = state(new WeakMap())
const mapSpy = jest.fn(() => (dummy = map.get(key)))
effect(mapSpy)
it('should not observe raw data', () => {
let dummy
const key = {}
- const map = observable(new WeakMap())
- effect(() => (dummy = unwrap(map).get(key)))
+ const map = state(new WeakMap())
+ effect(() => (dummy = toRaw(map).get(key)))
expect(dummy).toBe(undefined)
map.set(key, 'Hello')
it('should not pollute original Map with Proxies', () => {
const map = new WeakMap()
- const observed = observable(map)
+ const observed = state(map)
const key = {}
- const value = observable({})
+ const value = state({})
observed.set(key, value)
expect(map.get(key)).not.toBe(value)
- expect(map.get(key)).toBe(unwrap(value))
+ expect(map.get(key)).toBe(toRaw(value))
})
it('should return observable versions of contained values', () => {
- const observed = observable(new WeakMap())
+ const observed = state(new WeakMap())
const key = {}
const value = {}
observed.set(key, value)
const wrapped = observed.get(key)
- expect(isObservable(wrapped)).toBe(true)
- expect(unwrap(wrapped)).toBe(value)
+ expect(isState(wrapped)).toBe(true)
+ expect(toRaw(wrapped)).toBe(value)
})
it('should observed nested data', () => {
- const observed = observable(new Map())
+ const observed = state(new Map())
const key = {}
observed.set(key, { a: 1 })
let dummy
-import { observable, isObservable, effect, unwrap } from '../../src'
+import { state, isState, effect, toRaw } from '../../src'
describe('observer/collections', () => {
describe('WeakSet', () => {
it('instanceof', () => {
const original = new Set()
- const observed = observable(original)
- expect(isObservable(observed)).toBe(true)
+ const observed = state(original)
+ expect(isState(observed)).toBe(true)
expect(original instanceof Set).toBe(true)
expect(observed instanceof Set).toBe(true)
})
it('should observe mutations', () => {
let dummy
const value = {}
- const set = observable(new WeakSet())
+ const set = state(new WeakSet())
effect(() => (dummy = set.has(value)))
expect(dummy).toBe(false)
it('should not observe custom property mutations', () => {
let dummy
- const set: any = observable(new WeakSet())
+ const set: any = state(new WeakSet())
effect(() => (dummy = set.customProp))
expect(dummy).toBe(undefined)
it('should not observe non value changing mutations', () => {
let dummy
const value = {}
- const set = observable(new WeakSet())
+ const set = state(new WeakSet())
const setSpy = jest.fn(() => (dummy = set.has(value)))
effect(setSpy)
it('should not observe raw data', () => {
const value = {}
let dummy
- const set = observable(new WeakSet())
- effect(() => (dummy = unwrap(set).has(value)))
+ const set = state(new WeakSet())
+ effect(() => (dummy = toRaw(set).has(value)))
expect(dummy).toBe(false)
set.add(value)
it('should not be triggered by raw mutations', () => {
const value = {}
let dummy
- const set = observable(new WeakSet())
+ const set = state(new WeakSet())
effect(() => (dummy = set.has(value)))
expect(dummy).toBe(false)
- unwrap(set).add(value)
+ toRaw(set).add(value)
expect(dummy).toBe(false)
})
it('should not pollute original Set with Proxies', () => {
const set = new WeakSet()
- const observed = observable(set)
- const value = observable({})
+ const observed = state(set)
+ const value = state({})
observed.add(value)
expect(observed.has(value)).toBe(true)
expect(set.has(value)).toBe(false)
-import { computed, observable, effect, stop } from '../src'
+import { computed, state, effect, stop } from '../src'
describe('observer/computed', () => {
it('should return updated value', () => {
- const value: any = observable({})
+ const value: any = state({})
const cValue = computed(() => value.foo)
expect(cValue.value).toBe(undefined)
value.foo = 1
})
it('should compute lazily', () => {
- const value: any = observable({})
+ const value: any = state({})
const getter = jest.fn(() => value.foo)
const cValue = computed(getter)
})
it('should trigger effect', () => {
- const value: any = observable({})
+ const value: any = state({})
const cValue = computed(() => value.foo)
let dummy
effect(() => {
})
it('should work when chained', () => {
- const value: any = observable({ foo: 0 })
+ const value: any = state({ foo: 0 })
const c1 = computed(() => value.foo)
const c2 = computed(() => c1.value + 1)
expect(c2.value).toBe(1)
})
it('should trigger effect when chained', () => {
- const value: any = observable({ foo: 0 })
+ const value: any = state({ foo: 0 })
const getter1 = jest.fn(() => value.foo)
const getter2 = jest.fn(() => {
return c1.value + 1
})
it('should trigger effect when chained (mixed invocations)', () => {
- const value: any = observable({ foo: 0 })
+ const value: any = state({ foo: 0 })
const getter1 = jest.fn(() => value.foo)
const getter2 = jest.fn(() => {
return c1.value + 1
})
it('should no longer update when stopped', () => {
- const value: any = observable({})
+ const value: any = state({})
const cValue = computed(() => value.foo)
let dummy
effect(() => {
import {
- observable,
+ state,
effect,
stop,
- unwrap,
+ toRaw,
OperationTypes,
DebuggerEvent,
markNonReactive
it('should observe basic properties', () => {
let dummy
- const counter = observable({ num: 0 })
+ const counter = state({ num: 0 })
effect(() => (dummy = counter.num))
expect(dummy).toBe(0)
it('should observe multiple properties', () => {
let dummy
- const counter = observable({ num1: 0, num2: 0 })
+ const counter = state({ num1: 0, num2: 0 })
effect(() => (dummy = counter.num1 + counter.num1 + counter.num2))
expect(dummy).toBe(0)
it('should handle multiple effects', () => {
let dummy1, dummy2
- const counter = observable({ num: 0 })
+ const counter = state({ num: 0 })
effect(() => (dummy1 = counter.num))
effect(() => (dummy2 = counter.num))
it('should observe nested properties', () => {
let dummy
- const counter = observable({ nested: { num: 0 } })
+ const counter = state({ nested: { num: 0 } })
effect(() => (dummy = counter.nested.num))
expect(dummy).toBe(0)
it('should observe delete operations', () => {
let dummy
- const obj = observable({ prop: 'value' })
+ const obj = state({ prop: 'value' })
effect(() => (dummy = obj.prop))
expect(dummy).toBe('value')
it('should observe has operations', () => {
let dummy
- const obj: any = observable({ prop: 'value' })
+ const obj: any = state({ prop: 'value' })
effect(() => (dummy = 'prop' in obj))
expect(dummy).toBe(true)
it('should observe properties on the prototype chain', () => {
let dummy
- const counter = observable({ num: 0 })
- const parentCounter = observable({ num: 2 })
+ const counter = state({ num: 0 })
+ const parentCounter = state({ num: 2 })
Object.setPrototypeOf(counter, parentCounter)
effect(() => (dummy = counter.num))
it('should observe has operations on the prototype chain', () => {
let dummy
- const counter = observable({ num: 0 })
- const parentCounter = observable({ num: 2 })
+ const counter = state({ num: 0 })
+ const parentCounter = state({ num: 2 })
Object.setPrototypeOf(counter, parentCounter)
effect(() => (dummy = 'num' in counter))
it('should observe inherited property accessors', () => {
let dummy, parentDummy, hiddenValue: any
- const obj: any = observable({})
- const parent = observable({
+ const obj: any = state({})
+ const parent = state({
set prop(value) {
hiddenValue = value
},
it('should observe function call chains', () => {
let dummy
- const counter = observable({ num: 0 })
+ const counter = state({ num: 0 })
effect(() => (dummy = getNum()))
function getNum() {
it('should observe iteration', () => {
let dummy
- const list = observable(['Hello'])
+ const list = state(['Hello'])
effect(() => (dummy = list.join(' ')))
expect(dummy).toBe('Hello')
it('should observe implicit array length changes', () => {
let dummy
- const list = observable(['Hello'])
+ const list = state(['Hello'])
effect(() => (dummy = list.join(' ')))
expect(dummy).toBe('Hello')
it('should observe sparse array mutations', () => {
let dummy
- const list: any[] = observable([])
+ const list: any[] = state([])
list[1] = 'World!'
effect(() => (dummy = list.join(' ')))
it('should observe enumeration', () => {
let dummy = 0
- const numbers: any = observable({ num1: 3 })
+ const numbers: any = state({ num1: 3 })
effect(() => {
dummy = 0
for (let key in numbers) {
it('should observe symbol keyed properties', () => {
const key = Symbol('symbol keyed prop')
let dummy, hasDummy
- const obj = observable({ [key]: 'value' })
+ const obj = state({ [key]: 'value' })
effect(() => (dummy = obj[key]))
effect(() => (hasDummy = key in obj))
it('should not observe well-known symbol keyed properties', () => {
const key = Symbol.isConcatSpreadable
let dummy
- const array: any = observable([])
+ const array: any = state([])
effect(() => (dummy = array[key]))
expect(array[key]).toBe(undefined)
const newFunc = () => {}
let dummy
- const obj = observable({ func: oldFunc })
+ const obj = state({ func: oldFunc })
effect(() => (dummy = obj.func))
expect(dummy).toBe(oldFunc)
it('should not observe set operations without a value change', () => {
let hasDummy, getDummy
- const obj = observable({ prop: 'value' })
+ const obj = state({ prop: 'value' })
const getSpy = jest.fn(() => (getDummy = obj.prop))
const hasSpy = jest.fn(() => (hasDummy = 'prop' in obj))
it('should not observe raw mutations', () => {
let dummy
- const obj: any = observable()
- effect(() => (dummy = unwrap(obj).prop))
+ const obj: any = state()
+ effect(() => (dummy = toRaw(obj).prop))
expect(dummy).toBe(undefined)
obj.prop = 'value'
it('should not be triggered by raw mutations', () => {
let dummy
- const obj: any = observable()
+ const obj: any = state()
effect(() => (dummy = obj.prop))
expect(dummy).toBe(undefined)
- unwrap(obj).prop = 'value'
+ toRaw(obj).prop = 'value'
expect(dummy).toBe(undefined)
})
it('should not be triggered by inherited raw setters', () => {
let dummy, parentDummy, hiddenValue: any
- const obj: any = observable({})
- const parent = observable({
+ const obj: any = state({})
+ const parent = state({
set prop(value) {
hiddenValue = value
},
expect(dummy).toBe(undefined)
expect(parentDummy).toBe(undefined)
- unwrap(obj).prop = 4
+ toRaw(obj).prop = 4
expect(dummy).toBe(undefined)
expect(parentDummy).toBe(undefined)
})
it('should avoid implicit infinite recursive loops with itself', () => {
- const counter = observable({ num: 0 })
+ const counter = state({ num: 0 })
const counterSpy = jest.fn(() => counter.num++)
effect(counterSpy)
})
it('should allow explicitly recursive raw function loops', () => {
- const counter = observable({ num: 0 })
+ const counter = state({ num: 0 })
const numSpy = jest.fn(() => {
counter.num++
if (counter.num < 10) {
})
it('should avoid infinite loops with other effects', () => {
- const nums = observable({ num1: 0, num2: 1 })
+ const nums = state({ num1: 0, num2: 1 })
const spy1 = jest.fn(() => (nums.num1 = nums.num2))
const spy2 = jest.fn(() => (nums.num2 = nums.num1))
it('should discover new branches while running automatically', () => {
let dummy
- const obj = observable({ prop: 'value', run: false })
+ const obj = state({ prop: 'value', run: false })
const conditionalSpy = jest.fn(() => {
dummy = obj.run ? obj.prop : 'other'
it('should discover new branches when running manually', () => {
let dummy
let run = false
- const obj = observable({ prop: 'value' })
+ const obj = state({ prop: 'value' })
const runner = effect(() => {
dummy = run ? obj.prop : 'other'
})
it('should not be triggered by mutating a property, which is used in an inactive branch', () => {
let dummy
- const obj = observable({ prop: 'value', run: true })
+ const obj = state({ prop: 'value', run: true })
const conditionalSpy = jest.fn(() => {
dummy = obj.run ? obj.prop : 'other'
it('should not run multiple times for a single mutation', () => {
let dummy
- const obj: any = observable()
+ const obj: any = state()
const fnSpy = jest.fn(() => {
for (const key in obj) {
dummy = obj[key]
})
it('should allow nested effects', () => {
- const nums = observable({ num1: 0, num2: 1, num3: 2 })
+ const nums = state({ num1: 0, num2: 1, num3: 2 })
const dummy: any = {}
const childSpy = jest.fn(() => (dummy.num1 = nums.num1))
this.count++
}
}
- const model = observable(new Model())
+ const model = state(new Model())
let dummy
effect(() => {
dummy = model.count
const scheduler = jest.fn(_runner => {
runner = _runner
})
- const obj = observable({ foo: 1 })
+ const obj = state({ foo: 1 })
effect(
() => {
dummy = obj.foo
const onTrack = jest.fn((e: DebuggerEvent) => {
events.push(e)
})
- const obj = observable({ foo: 1, bar: 2 })
+ const obj = state({ foo: 1, bar: 2 })
const runner = effect(
() => {
dummy = obj.foo
expect(events).toEqual([
{
effect: runner,
- target: unwrap(obj),
+ target: toRaw(obj),
type: OperationTypes.GET,
key: 'foo'
},
{
effect: runner,
- target: unwrap(obj),
+ target: toRaw(obj),
type: OperationTypes.HAS,
key: 'bar'
},
{
effect: runner,
- target: unwrap(obj),
+ target: toRaw(obj),
type: OperationTypes.ITERATE,
key: ITERATE_KEY
}
const onTrigger = jest.fn((e: DebuggerEvent) => {
events.push(e)
})
- const obj = observable({ foo: 1 })
+ const obj = state({ foo: 1 })
const runner = effect(
() => {
dummy = obj.foo
expect(onTrigger).toHaveBeenCalledTimes(1)
expect(events[0]).toEqual({
effect: runner,
- target: unwrap(obj),
+ target: toRaw(obj),
type: OperationTypes.SET,
key: 'foo',
oldValue: 1,
expect(onTrigger).toHaveBeenCalledTimes(2)
expect(events[1]).toEqual({
effect: runner,
- target: unwrap(obj),
+ target: toRaw(obj),
type: OperationTypes.DELETE,
key: 'foo',
oldValue: 2
it('stop', () => {
let dummy
- const obj = observable({ prop: 1 })
+ const obj = state({ prop: 1 })
const runner = effect(() => {
dummy = obj.prop
})
})
it('markNonReactive', () => {
- const obj = observable({
+ const obj = state({
foo: markNonReactive({
prop: 0
})
import {
- observable,
- immutable,
- unwrap,
- isObservable,
- isImmutable,
+ state,
+ immutableState,
+ toRaw,
+ isState,
+ isImmutableState,
markNonReactive,
markImmutable,
lock,
describe('Object', () => {
it('should make nested values immutable', () => {
const original = { foo: 1, bar: { baz: 2 } }
- const observed = immutable(original)
+ const observed = immutableState(original)
expect(observed).not.toBe(original)
- expect(isObservable(observed)).toBe(true)
- expect(isImmutable(observed)).toBe(true)
- expect(isObservable(original)).toBe(false)
- expect(isImmutable(original)).toBe(false)
- expect(isObservable(observed.bar)).toBe(true)
- expect(isImmutable(observed.bar)).toBe(true)
- expect(isObservable(original.bar)).toBe(false)
- expect(isImmutable(original.bar)).toBe(false)
+ expect(isState(observed)).toBe(true)
+ expect(isImmutableState(observed)).toBe(true)
+ expect(isState(original)).toBe(false)
+ expect(isImmutableState(original)).toBe(false)
+ expect(isState(observed.bar)).toBe(true)
+ expect(isImmutableState(observed.bar)).toBe(true)
+ expect(isState(original.bar)).toBe(false)
+ expect(isImmutableState(original.bar)).toBe(false)
// get
expect(observed.foo).toBe(1)
// has
})
it('should not allow mutation', () => {
- const observed = immutable({ foo: 1, bar: { baz: 2 } })
+ const observed = immutableState({ foo: 1, bar: { baz: 2 } })
observed.foo = 2
expect(observed.foo).toBe(1)
expect(warn).toHaveBeenCalledTimes(1)
})
it('should allow mutation when unlocked', () => {
- const observed: any = immutable({ foo: 1, bar: { baz: 2 } })
+ const observed: any = immutableState({ foo: 1, bar: { baz: 2 } })
unlock()
observed.prop = 2
observed.bar.qux = 3
})
it('should not trigger effects when locked', () => {
- const observed = immutable({ a: 1 })
+ const observed = immutableState({ a: 1 })
let dummy
effect(() => {
dummy = observed.a
})
it('should trigger effects when unlocked', () => {
- const observed = immutable({ a: 1 })
+ const observed = immutableState({ a: 1 })
let dummy
effect(() => {
dummy = observed.a
describe('Array', () => {
it('should make nested values immutable', () => {
const original: any[] = [{ foo: 1 }]
- const observed = immutable(original)
+ const observed = immutableState(original)
expect(observed).not.toBe(original)
- expect(isObservable(observed)).toBe(true)
- expect(isImmutable(observed)).toBe(true)
- expect(isObservable(original)).toBe(false)
- expect(isImmutable(original)).toBe(false)
- expect(isObservable(observed[0])).toBe(true)
- expect(isImmutable(observed[0])).toBe(true)
- expect(isObservable(original[0])).toBe(false)
- expect(isImmutable(original[0])).toBe(false)
+ expect(isState(observed)).toBe(true)
+ expect(isImmutableState(observed)).toBe(true)
+ expect(isState(original)).toBe(false)
+ expect(isImmutableState(original)).toBe(false)
+ expect(isState(observed[0])).toBe(true)
+ expect(isImmutableState(observed[0])).toBe(true)
+ expect(isState(original[0])).toBe(false)
+ expect(isImmutableState(original[0])).toBe(false)
// get
expect(observed[0].foo).toBe(1)
// has
})
it('should not allow mutation', () => {
- const observed: any = immutable([{ foo: 1 }])
+ const observed: any = immutableState([{ foo: 1 }])
observed[0] = 1
expect(observed[0]).not.toBe(1)
expect(warn).toHaveBeenCalledTimes(1)
})
it('should allow mutation when unlocked', () => {
- const observed: any[] = immutable([{ foo: 1, bar: { baz: 2 } }])
+ const observed: any[] = immutableState([{ foo: 1, bar: { baz: 2 } }])
unlock()
observed[1] = 2
observed.push(3)
})
it('should not trigger effects when locked', () => {
- const observed = immutable([{ a: 1 }])
+ const observed = immutableState([{ a: 1 }])
let dummy
effect(() => {
dummy = observed[0].a
})
it('should trigger effects when unlocked', () => {
- const observed = immutable([{ a: 1 }])
+ const observed = immutableState([{ a: 1 }])
let dummy
effect(() => {
dummy = observed[0].a
const key1 = {}
const key2 = {}
const original = new Collection([[key1, {}], [key2, {}]])
- const observed = immutable(original)
+ const observed = immutableState(original)
expect(observed).not.toBe(original)
- expect(isObservable(observed)).toBe(true)
- expect(isImmutable(observed)).toBe(true)
- expect(isObservable(original)).toBe(false)
- expect(isImmutable(original)).toBe(false)
- expect(isObservable(observed.get(key1))).toBe(true)
- expect(isImmutable(observed.get(key1))).toBe(true)
- expect(isObservable(original.get(key1))).toBe(false)
- expect(isImmutable(original.get(key1))).toBe(false)
+ expect(isState(observed)).toBe(true)
+ expect(isImmutableState(observed)).toBe(true)
+ expect(isState(original)).toBe(false)
+ expect(isImmutableState(original)).toBe(false)
+ expect(isState(observed.get(key1))).toBe(true)
+ expect(isImmutableState(observed.get(key1))).toBe(true)
+ expect(isState(original.get(key1))).toBe(false)
+ expect(isImmutableState(original.get(key1))).toBe(false)
})
test('should not allow mutation & not trigger effect', () => {
- const map = immutable(new Collection())
+ const map = immutableState(new Collection())
const key = {}
let dummy
effect(() => {
})
test('should allow mutation & trigger effect when unlocked', () => {
- const map = immutable(new Collection())
+ const map = immutableState(new Collection())
const isWeak = Collection === WeakMap
const key = {}
let dummy
const key1 = {}
const key2 = {}
const original = new Collection([[key1, {}], [key2, {}]])
- const observed = immutable(original)
+ const observed = immutableState(original)
for (const [key, value] of observed) {
- expect(isImmutable(key)).toBe(true)
- expect(isImmutable(value)).toBe(true)
+ expect(isImmutableState(key)).toBe(true)
+ expect(isImmutableState(value)).toBe(true)
}
observed.forEach((value: any) => {
- expect(isImmutable(value)).toBe(true)
+ expect(isImmutableState(value)).toBe(true)
})
for (const value of observed.values()) {
- expect(isImmutable(value)).toBe(true)
+ expect(isImmutableState(value)).toBe(true)
}
})
}
const key1 = {}
const key2 = {}
const original = new Collection([key1, key2])
- const observed = immutable(original)
+ const observed = immutableState(original)
expect(observed).not.toBe(original)
- expect(isObservable(observed)).toBe(true)
- expect(isImmutable(observed)).toBe(true)
- expect(isObservable(original)).toBe(false)
- expect(isImmutable(original)).toBe(false)
- expect(observed.has(observable(key1))).toBe(true)
- expect(original.has(observable(key1))).toBe(false)
+ expect(isState(observed)).toBe(true)
+ expect(isImmutableState(observed)).toBe(true)
+ expect(isState(original)).toBe(false)
+ expect(isImmutableState(original)).toBe(false)
+ expect(observed.has(state(key1))).toBe(true)
+ expect(original.has(state(key1))).toBe(false)
})
test('should not allow mutation & not trigger effect', () => {
- const set = immutable(new Collection())
+ const set = immutableState(new Collection())
const key = {}
let dummy
effect(() => {
})
test('should allow mutation & trigger effect when unlocked', () => {
- const set = immutable(new Collection())
+ const set = immutableState(new Collection())
const key = {}
let dummy
effect(() => {
if (Collection === Set) {
test('should retrive immutable values on iteration', () => {
const original = new Collection([{}, {}])
- const observed = immutable(original)
+ const observed = immutableState(original)
for (const value of observed) {
- expect(isImmutable(value)).toBe(true)
+ expect(isImmutableState(value)).toBe(true)
}
observed.forEach((value: any) => {
- expect(isImmutable(value)).toBe(true)
+ expect(isImmutableState(value)).toBe(true)
})
for (const value of observed.values()) {
- expect(isImmutable(value)).toBe(true)
+ expect(isImmutableState(value)).toBe(true)
}
for (const [v1, v2] of observed.entries()) {
- expect(isImmutable(v1)).toBe(true)
- expect(isImmutable(v2)).toBe(true)
+ expect(isImmutableState(v1)).toBe(true)
+ expect(isImmutableState(v2)).toBe(true)
}
})
}
})
test('calling observable on an immutable should return immutable', () => {
- const a = immutable()
- const b = observable(a)
- expect(isImmutable(b)).toBe(true)
+ const a = immutableState()
+ const b = state(a)
+ expect(isImmutableState(b)).toBe(true)
// should point to same original
- expect(unwrap(a)).toBe(unwrap(b))
+ expect(toRaw(a)).toBe(toRaw(b))
})
test('calling immutable on an observable should return immutable', () => {
- const a = observable()
- const b = immutable(a)
- expect(isImmutable(b)).toBe(true)
+ const a = state()
+ const b = immutableState(a)
+ expect(isImmutableState(b)).toBe(true)
// should point to same original
- expect(unwrap(a)).toBe(unwrap(b))
+ expect(toRaw(a)).toBe(toRaw(b))
})
test('observing already observed value should return same Proxy', () => {
const original = { foo: 1 }
- const observed = immutable(original)
- const observed2 = immutable(observed)
+ const observed = immutableState(original)
+ const observed2 = immutableState(observed)
expect(observed2).toBe(observed)
})
test('observing the same value multiple times should return same Proxy', () => {
const original = { foo: 1 }
- const observed = immutable(original)
- const observed2 = immutable(original)
+ const observed = immutableState(original)
+ const observed2 = immutableState(original)
expect(observed2).toBe(observed)
})
test('markNonReactive', () => {
- const obj = immutable({
+ const obj = immutableState({
foo: { a: 1 },
bar: markNonReactive({ b: 2 })
})
- expect(isObservable(obj.foo)).toBe(true)
- expect(isObservable(obj.bar)).toBe(false)
+ expect(isState(obj.foo)).toBe(true)
+ expect(isState(obj.bar)).toBe(false)
})
test('markImmutable', () => {
- const obj = observable({
+ const obj = state({
foo: { a: 1 },
bar: markImmutable({ b: 2 })
})
- expect(isObservable(obj.foo)).toBe(true)
- expect(isObservable(obj.bar)).toBe(true)
- expect(isImmutable(obj.foo)).toBe(false)
- expect(isImmutable(obj.bar)).toBe(true)
+ expect(isState(obj.foo)).toBe(true)
+ expect(isState(obj.bar)).toBe(true)
+ expect(isImmutableState(obj.foo)).toBe(false)
+ expect(isImmutableState(obj.bar)).toBe(true)
})
})
-import { observable, isObservable, unwrap, markNonReactive } from '../src/index'
+import { state, isState, toRaw, markNonReactive } from '../src/index'
describe('observer/observable', () => {
test('Object', () => {
const original = { foo: 1 }
- const observed = observable(original)
+ const observed = state(original)
expect(observed).not.toBe(original)
- expect(isObservable(observed)).toBe(true)
- expect(isObservable(original)).toBe(false)
+ expect(isState(observed)).toBe(true)
+ expect(isState(original)).toBe(false)
// get
expect(observed.foo).toBe(1)
// has
test('Array', () => {
const original: any[] = [{ foo: 1 }]
- const observed = observable(original)
+ const observed = state(original)
expect(observed).not.toBe(original)
- expect(isObservable(observed)).toBe(true)
- expect(isObservable(original)).toBe(false)
- expect(isObservable(observed[0])).toBe(true)
+ expect(isState(observed)).toBe(true)
+ expect(isState(original)).toBe(false)
+ expect(isState(observed[0])).toBe(true)
// get
expect(observed[0].foo).toBe(1)
// has
test('cloned observable Array should point to observed values', () => {
const original = [{ foo: 1 }]
- const observed = observable(original)
+ const observed = state(original)
const clone = observed.slice()
- expect(isObservable(clone[0])).toBe(true)
+ expect(isState(clone[0])).toBe(true)
expect(clone[0]).not.toBe(original[0])
expect(clone[0]).toBe(observed[0])
})
},
array: [{ bar: 2 }]
}
- const observed = observable(original)
- expect(isObservable(observed.nested)).toBe(true)
- expect(isObservable(observed.array)).toBe(true)
- expect(isObservable(observed.array[0])).toBe(true)
+ const observed = state(original)
+ expect(isState(observed.nested)).toBe(true)
+ expect(isState(observed.array)).toBe(true)
+ expect(isState(observed.array[0])).toBe(true)
})
test('observed value should proxy mutations to original (Object)', () => {
const original: any = { foo: 1 }
- const observed = observable(original)
+ const observed = state(original)
// set
observed.bar = 1
expect(observed.bar).toBe(1)
test('observed value should proxy mutations to original (Array)', () => {
const original: any[] = [{ foo: 1 }, { bar: 2 }]
- const observed = observable(original)
+ const observed = state(original)
// set
const value = { baz: 3 }
- const observableValue = observable(value)
+ const observableValue = state(value)
observed[0] = value
expect(observed[0]).toBe(observableValue)
expect(original[0]).toBe(value)
})
test('setting a property with an unobserved value should wrap with observable', () => {
- const observed: any = observable({})
+ const observed: any = state({})
const raw = {}
observed.foo = raw
expect(observed.foo).not.toBe(raw)
- expect(isObservable(observed.foo)).toBe(true)
+ expect(isState(observed.foo)).toBe(true)
})
test('observing already observed value should return same Proxy', () => {
const original = { foo: 1 }
- const observed = observable(original)
- const observed2 = observable(observed)
+ const observed = state(original)
+ const observed2 = state(observed)
expect(observed2).toBe(observed)
})
test('observing the same value multiple times should return same Proxy', () => {
const original = { foo: 1 }
- const observed = observable(original)
- const observed2 = observable(original)
+ const observed = state(original)
+ const observed2 = state(original)
expect(observed2).toBe(observed)
})
test('should not pollute original object with Proxies', () => {
const original: any = { foo: 1 }
const original2 = { bar: 2 }
- const observed = observable(original)
- const observed2 = observable(original2)
+ const observed = state(original)
+ const observed2 = state(original2)
observed.bar = observed2
expect(observed.bar).toBe(observed2)
expect(original.bar).toBe(original2)
test('unwrap', () => {
const original = { foo: 1 }
- const observed = observable(original)
- expect(unwrap(observed)).toBe(original)
- expect(unwrap(original)).toBe(original)
+ const observed = state(original)
+ expect(toRaw(observed)).toBe(original)
+ expect(toRaw(original)).toBe(original)
})
test('unobservable values', () => {
const getMsg = (value: any) => `value is not observable: ${String(value)}`
const assertValue = (value: any) => {
- observable(value)
+ state(value)
expect(lastMsg).toMatch(getMsg(value))
}
assertValue(null)
// undefined should work because it returns empty object observable
lastMsg = ''
- observable(undefined)
+ state(undefined)
expect(lastMsg).toBe('')
// symbol
const s = Symbol()
// built-ins should work and return same value
const p = Promise.resolve()
- expect(observable(p)).toBe(p)
+ expect(state(p)).toBe(p)
const r = new RegExp('')
- expect(observable(r)).toBe(r)
+ expect(state(r)).toBe(r)
const d = new Date()
- expect(observable(d)).toBe(d)
+ expect(state(d)).toBe(d)
})
test('markNonReactive', () => {
- const obj = observable({
+ const obj = state({
foo: { a: 1 },
bar: markNonReactive({ b: 2 })
})
- expect(isObservable(obj.foo)).toBe(true)
- expect(isObservable(obj.bar)).toBe(false)
+ expect(isState(obj.foo)).toBe(true)
+ expect(isState(obj.bar)).toBe(false)
})
})
import { value } from '../src/value'
-import { effect, observable } from '../src/index'
+import { effect, state } from '../src/index'
describe('observer/value', () => {
it('should hold a value', () => {
it('should work like a normal property when nested in an observable', () => {
const a = value(1)
- const obj = observable({
+ const obj = state({
a,
b: {
c: a,
--- /dev/null
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+ module.exports = require('./dist/reactivity.cjs.prod.js.js')
+} else {
+ module.exports = require('./dist/reactivity.cjs.js.js')
+}
{
- "name": "@vue/observer",
+ "name": "@vue/reactivity",
"version": "3.0.0-alpha.1",
- "description": "@vue/observer",
+ "description": "@vue/reactivity",
"main": "index.js",
- "module": "dist/observer.esm-bundler.js",
+ "module": "dist/reactivity.esm-bundler.js",
"types": "dist/index.d.ts",
- "unpkg": "dist/observer.global.js",
+ "unpkg": "dist/reactivity.global.js",
"sideEffects": false,
"repository": {
"type": "git",
"bugs": {
"url": "https://github.com/vuejs/vue/issues"
},
- "homepage": "https://github.com/vuejs/vue/tree/dev/packages/observer#readme"
+ "homepage": "https://github.com/vuejs/vue/tree/dev/packages/reactivity#readme"
}
-import { observable, immutable, unwrap } from './index'
+import { state, immutableState, toRaw } from './index'
import { OperationTypes } from './operations'
import { track, trigger } from './effect'
import { LOCKED } from './lock'
? isImmutable
? // need to lazy access immutable and observable here to avoid
// circular dependency
- immutable(res)
- : observable(res)
+ immutableState(res)
+ : state(res)
: res
}
}
value: any,
receiver: any
): boolean {
- value = unwrap(value)
+ value = toRaw(value)
const hadKey = hasOwnProperty.call(target, key)
const oldValue = target[key]
if (isValue(oldValue)) {
}
const result = Reflect.set(target, key, value, receiver)
// don't trigger if target is something up in the prototype chain of original
- if (target === unwrap(receiver)) {
+ if (target === toRaw(receiver)) {
/* istanbul ignore else */
if (__DEV__) {
const extraInfo = { oldValue, newValue: value }
-import { unwrap, observable, immutable } from './index'
+import { toRaw, state, immutableState } from './index'
import { track, trigger } from './effect'
import { OperationTypes } from './operations'
import { LOCKED } from './lock'
import { isObject } from '@vue/shared'
-const toObservable = (value: any) =>
- isObject(value) ? observable(value) : value
-const toImmutable = (value: any) => (isObject(value) ? immutable(value) : value)
+const toObservable = (value: any) => (isObject(value) ? state(value) : value)
+const toImmutable = (value: any) =>
+ isObject(value) ? immutableState(value) : value
function get(target: any, key: any, wrap: (t: any) => any): any {
- target = unwrap(target)
- key = unwrap(key)
+ target = toRaw(target)
+ key = toRaw(key)
const proto: any = Reflect.getPrototypeOf(target)
track(target, OperationTypes.GET, key)
const res = proto.get.call(target, key)
}
function has(key: any): boolean {
- const target = unwrap(this)
- key = unwrap(key)
+ const target = toRaw(this)
+ key = toRaw(key)
const proto: any = Reflect.getPrototypeOf(target)
track(target, OperationTypes.HAS, key)
return proto.has.call(target, key)
}
function size(target: any) {
- target = unwrap(target)
+ target = toRaw(target)
const proto = Reflect.getPrototypeOf(target)
track(target, OperationTypes.ITERATE)
return Reflect.get(proto, 'size', target)
}
function add(value: any) {
- value = unwrap(value)
- const target = unwrap(this)
+ value = toRaw(value)
+ const target = toRaw(this)
const proto: any = Reflect.getPrototypeOf(this)
const hadKey = proto.has.call(target, value)
const result = proto.add.call(target, value)
}
function set(key: any, value: any) {
- value = unwrap(value)
- const target = unwrap(this)
+ value = toRaw(value)
+ const target = toRaw(this)
const proto: any = Reflect.getPrototypeOf(this)
const hadKey = proto.has.call(target, key)
const oldValue = proto.get.call(target, key)
}
function deleteEntry(key: any) {
- const target = unwrap(this)
+ const target = toRaw(this)
const proto: any = Reflect.getPrototypeOf(this)
const hadKey = proto.has.call(target, key)
const oldValue = proto.get ? proto.get.call(target, key) : undefined
}
function clear() {
- const target = unwrap(this)
+ const target = toRaw(this)
const proto: any = Reflect.getPrototypeOf(this)
const hadItems = target.size !== 0
const oldTarget = target instanceof Map ? new Map(target) : new Set(target)
function createForEach(isImmutable: boolean) {
return function forEach(callback: Function, thisArg?: any) {
const observed = this
- const target = unwrap(observed)
+ const target = toRaw(observed)
const proto: any = Reflect.getPrototypeOf(target)
const wrap = isImmutable ? toImmutable : toObservable
track(target, OperationTypes.ITERATE)
function createIterableMethod(method: string | symbol, isImmutable: boolean) {
return function(...args: any[]) {
- const target = unwrap(this)
+ const target = toRaw(this)
const proto: any = Reflect.getPrototypeOf(target)
const isPair =
method === 'entries' ||
const key = args[0] ? `on key "${args[0]}"` : ``
console.warn(
`${type} operation ${key}failed: target is immutable.`,
- unwrap(this)
+ toRaw(this)
)
}
return type === OperationTypes.DELETE ? false : this
export type Scheduler = (run: () => any) => void
-export type DebuggerEvent = {
+export interface DebuggerEvent {
effect: ReactiveEffect
target: any
type: OperationTypes
type ObservableFactory = <T>(target?: T) => UnwrapValue<T>
-export const observable = ((target: any = {}): any => {
+export const state = ((target: any = {}): any => {
// if trying to observe an immutable proxy, return the immutable version.
if (immutableToRaw.has(target)) {
return target
}
// target is explicitly marked as immutable by user
if (immutableValues.has(target)) {
- return immutable(target)
+ return immutableState(target)
}
return createObservable(
target,
)
}) as ObservableFactory
-export const immutable = ((target: any = {}): any => {
+export const immutableState = ((target: any = {}): any => {
// value is a mutable observable, retrive its original and return
// a readonly version.
if (observedToRaw.has(target)) {
}
}
-export function isObservable(value: any): boolean {
+export function isState(value: any): boolean {
return observedToRaw.has(value) || immutableToRaw.has(value)
}
-export function isImmutable(value: any): boolean {
+export function isImmutableState(value: any): boolean {
return immutableToRaw.has(value)
}
-export function unwrap<T>(observed: T): T {
+export function toRaw<T>(observed: T): T {
return observedToRaw.get(observed) || immutableToRaw.get(observed) || observed
}
import { track, trigger } from './effect'
import { OperationTypes } from './operations'
import { isObject } from '@vue/shared'
-import { observable } from './index'
+import { state } from './index'
export const knownValues = new WeakSet()
value: T
}
-const convert = (val: any): any => (isObject(val) ? observable(val) : val)
+const convert = (val: any): any => (isObject(val) ? state(val) : val)
export function value<T>(raw: T): Value<T> {
raw = convert(raw)
import { createComponent } from '../src/component'
-import { value } from '@vue/observer'
+import { value } from '@vue/reactivity'
import { PropType } from '../src/componentProps'
test('createComponent type inference', () => {
export {
value,
isValue,
- observable,
- immutable,
- isObservable,
- isImmutable,
- unwrap,
+ state,
+ isState,
+ immutableState,
+ isImmutableState,
+ toRaw,
markImmutable,
markNonReactive,
effect,
Value,
ComputedValue,
UnwrapValue
-} from '@vue/observer'
+} from '@vue/reactivity'
import {
computed as _computed,
ComputedValue,
ReactiveEffect
-} from '@vue/observer'
+} from '@vue/reactivity'
import { currentInstance } from './component'
isValue,
Value,
ReactiveEffectOptions
-} from '@vue/observer'
+} from '@vue/reactivity'
import { queueJob, queuePostFlushCb } from './scheduler'
import { EMPTY_OBJ, isObject, isArray } from '@vue/shared'
import { recordEffect } from './apiState'
import {
ReactiveEffect,
UnwrapValue,
- observable,
- immutable
-} from '@vue/observer'
+ state,
+ immutableState
+} from '@vue/reactivity'
import { EMPTY_OBJ } from '@vue/shared'
import { RenderProxyHandlers } from './componentProxy'
import { ComponentPropsOptions, ExtractPropTypes } from './componentProps'
// only need to create it if setup() actually expects it
// it will be updated in resolveProps() on updates before render
const propsProxy = (instance.propsProxy = setup.length
- ? immutable(instance.props)
+ ? immutableState(instance.props)
: null)
- instance.state = observable(setup.call(proxy, propsProxy))
+ instance.state = state(setup.call(proxy, propsProxy))
currentInstance = null
}
}
-import { immutable, unwrap, lock, unlock } from '@vue/observer'
+import { immutableState, toRaw, lock, unlock } from '@vue/reactivity'
import {
EMPTY_OBJ,
camelize,
}
// runtime validation
if (__DEV__ && rawProps) {
- validateProp(key, unwrap(rawProps[key]), opt, isAbsent)
+ validateProp(key, toRaw(rawProps[key]), opt, isAbsent)
}
}
} else {
// the props proxy
const { patchFlag } = instance.vnode
if (propsProxy !== null && (patchFlag === 0 || patchFlag & FULL_PROPS)) {
- const rawInitialProps = unwrap(propsProxy)
+ const rawInitialProps = toRaw(propsProxy)
for (const key in rawInitialProps) {
if (!props.hasOwnProperty(key)) {
delete propsProxy[key]
// lock immutable
lock()
- instance.props = __DEV__ ? immutable(props) : props
+ instance.props = __DEV__ ? immutableState(props) : props
instance.attrs = options
? __DEV__
- ? immutable(attrs)
+ ? immutableState(attrs)
: attrs
: instance.props
}
FULL_PROPS
} from './patchFlags'
import { queueJob, queuePostFlushCb, flushPostFlushCbs } from './scheduler'
-import { effect, stop, ReactiveEffectOptions } from '@vue/observer'
+import { effect, stop, ReactiveEffectOptions } from '@vue/reactivity'
import { resolveProps } from './componentProps'
import { resolveSlots } from './componentSlots'
import {
"@vue/runtime-core": ["packages/runtime-core/src"],
"@vue/runtime-dom": ["packages/runtime-dom/src"],
"@vue/runtime-test": ["packages/runtime-test/src"],
- "@vue/observer": ["packages/observer/src"],
+ "@vue/reactivity": ["packages/reactivity/src"],
"@vue/compiler-core": ["packages/compiler-core/src"],
"@vue/server-renderer": ["packages/server-renderer/src"]
}
projects / thirdparty / vuejs / core.git / commitdiff
