aberdeen 0.2.1 → 0.2.2

package/tests/map.js

@@ -1,76 +0,0 @@
-describe('The map() and multiMap() methods', () => {
-    it('transforms Maps to Maps', () => {
-        let store = new Store(objToMap({a: 0, b: 2, c: 3}))
-        let cnt1 = 0, cnt2 = 0
-
-        mount(document.body, () => {
-            let out = store.map(s => {
-                cnt1++
-                if (s.get()) return s.get()*10
-            })
-
-            out.onEach(s => {
-                cnt2++
-                text(s.index()+"="+s.get())
-            }, s => s.index())
-        })
-
-        assertBody(`"b=20" "c=30"`)
-        assertEqual([cnt1, cnt2], [3, 2])
-
-        store.merge(objToMap({a: 1, c: undefined}))
-        passTime()
-        assertBody(`"a=10" "b=20"`)
-        assertEqual([cnt1, cnt2], [4, 3])
-    })
-    it('transforms Arrays to Objects', () => {
-        let store = new Store(['a', 'b'])
-        let cnt1 = 0, cnt2 = 0
-        let out
-
-        mount(document.body, () => {
-            out = store.multiMap(s => {
-                cnt1++
-                return {[s.get()]: s.index()}
-            })
-
-            out.onEach(s => {
-                cnt2++
-                text(s.index()+'='+s.get())
-            }, s => -s.get())
-        })
-
-        assertEqual(out.peek(), objToMap({a: 0, b: 1}))
-        assertBody(`"b=1" "a=0"`)
-        assertEqual([cnt1, cnt2], [2, 2])
-
-        store.set(0, 'A')
-        store.push('c')
-        passTime()
-        assertEqual(store.peek(), ['A', 'b', 'c'])
-        assertEqual(out.peek(), objToMap({A: 0, b: 1, c: 2}))
-        assertBody(`"c=2" "b=1" "A=0"`)
-        assertEqual([cnt1, cnt2], [4, 4])
-    })
-    it('transforms Objects to Maps', () => {
-        let store = new Store({a: {a:[]}, b: new Map([[1,2], [3,4]]), c: {c:5}, d: {}, e: 123})
-        let cnt1 = 0
-        let out
-
-        observe(() => {
-            out = store.multiMap(s => {
-                cnt1++
-                return s.get()
-            })
-        })
-
-        assertEqual(out.peek(), new Map([['a',[]], [1,2], [3,4], ['c',5]]))
-        assertEqual(cnt1, 5)
-
-        store.delete('b')
-        store.set('a', {})
-        passTime()
-        assertEqual(out.peek(), new Map([['c',5]]))
-        assertEqual(cnt1, 6)
-    })
-})

package/tests/objmap.js

@@ -1,40 +0,0 @@
-describe('Objects and maps', () => {
-    it('map fetches with a limited depth', () => {
-        let store = new Store(objToMap({a: {b: {c: {d: 42}}}}))
-        
-        let res = store.query({depth: 2, type: 'map'})
-        assertEqual(res.size, 1)
-        assertEqual(res.get('a').get('b').get(), objToMap({c: {d: 42}}))
-    })
-    it('merges maps collapsing changes', () => {
-        for(let converter of [objToMap, a=>a]) {
-            let store = new Store(converter({a: 1, b: 2, c: 3, d: undefined}))
-            assertEqual(store.count(), 3)
-            let cnt = 0
-            mount(document.body, () => {
-                cnt++
-                text(store.get('a')+store.get('a')+store.get('b'))
-                store.get()
-                store.get()
-            })
-            assertBody(`"4"`)
-
-            store.set(converter({a: 3, b: 4}))
-            passTime()
-            assertBody(`"10"`)
-            assertEqual(cnt, 2)
-
-            store.merge(converter({c: 4}))
-            passTime()
-            assertBody(`"10"`)
-            assertEqual(cnt, 3)
-
-            unmount()
-        }
-    })
-
-	it('handles invalid indexes', () => {
-		let store = new Store({})
-        assertThrow('Invalid object index', () => store.set(true, 1))
-	})
-})

package/tests/onEach.js

@@ -1,392 +0,0 @@
-describe('onEach', function() {
-
-	it('ignores undefined values', () => {
-		let cnt = 0
-		mount(document.body, () => {
-			let store = new Store()
-			store.onEach(() => cnt++)
-		})
-		assertEqual(cnt, 0)
-	})
-
-	it('handles unsuitable store values', () => {
-		for(let value of [3, "", false]) {
-			let cnt = 0
-			mount(document.body, () => {
-				let store = new Store(value)
-				assertThrow(`onEach() attempted`, () => {
-					store.onEach(() => cnt++)
-				})
-
-			})
-			assertEqual(cnt, 0, "cnt mismatch for "+JSON.stringify(value))
-		}
-	})
-
-	it('does nothing for an empty map', () => {
-		let cnt = 0
-		mount(document.body, () => {
-			let store = new Store({})
-			store.onEach(function() {
-				cnt++
-			})
-		})
-		assertEqual(cnt, 0)
-	})
-
-
-	it('emits a single entry', () => {
-		let result = []
-		mount(document.body, () => {
-			let store = new Store({x: 3})
-			store.onEach(function(store) {
-				result.push([store.index(),store.get()])
-			})
-		})
-		assertEqual(result, [['x', 3]])
-	})
-
-	it('emits multiple entries', () => {
-		let result = []
-		mount(document.body, () => {
-			let store = new Store({x: 3, y: 4, z: 5})
-			store.onEach(function(store) {
-				result.push([store.index(),store.get()])
-			})
-			// The order is undefined, so we'll sort it
-			result.sort((a,b) => a[1] - b[1])
-		})
-		assertEqual(result, [['x', 3], ['y', 4], ['z', 5]])
-	})
-
-	it('adds a single item to the DOM', () => {
-		mount(document.body, () => {
-			let store = new Store({x: 3})
-			store.onEach(function(store) {
-				node('p', {className: store.index()}, store.getNumber())
-			})
-		})
-		assertBody(`p{@class="x" "3"}`)
-	})
-
-	it('adds multiple items to the DOM in default order', () => {
-		mount(document.body, () => {
-			let store = new Store({c: 3, a: 1, b: 2})
-			store.onEach(function(store) {
-				node('p', store.index())
-			})
-		})
-		assertBody(`p{"a"} p{"b"} p{"c"}`)
-	})
-
-	it('maintains the last-element marker', () => {
-		mount(document.body, () => {
-			let store = new Store({c: 3, a: 1, b: 2})
-			store.onEach(function(store) {
-				node('p', store.index())
-			})
-			node('div')
-		})
-		assertBody(`p{"a"} p{"b"} p{"c"} div{}`)
-	})
-
-	it('maintains position for items', () => {
-		let store = new Store({0: false, 1: false, 2: false, 3: false})
-		let cnts = [0,0,0,0];
-		mount(document.body, () => {
-			store.onEach(item => {
-				cnts[item.index()]++;
-				if (item.getBoolean()) node('p', {id: item.index()})
-			})
-		})
-
-		assertBody(``);
-		assertEqual(cnts, [1,1,1,1]);
-
-		store.merge({1: true});
-		passTime();
-		assertBody(`p{@id="1"}`)
-		assertEqual(cnts, [1,2,1,1]);
-
-		store.merge({0: true, 2: true, 3: true});
-		passTime();
-		assertBody(`p{@id="0"} p{@id="1"} p{@id="2"} p{@id="3"}`)
-		assertEqual(cnts, [2,2,2,2]);
-	})
-
-	it('adds items in the right position', () => {
-		let store = new Store({});
-
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-			})
-		})
-
-		let items = ['d', 'a', 'b', 'f', 'c', 'e'];
-		let seen = [];
-
-		for(let item of items) {
-			seen.push(item+'{}')
-			seen.sort();
-
-			store.set(item, true);
-			passTime()
-			assertBody(seen.join(' '))
-		}
-	})
-
-	it('removes items and calls cleaners', () => {
-		let items = ['d', 'a', 'b', 'f', 'c', 'e']
-		let store = new Store({})
-		for(let item of items) {
-			store.set(item, true)
-		}
-		let cleaned = [];
-
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-				clean(() => {
-					cleaned.push(item.index())
-				});
-			})
-		})
-
-		let current = items.slice().sort();
-
-		let cleanedExpected = [];
-
-		for(let item of items) {
-			current.splice(current.indexOf(item), 1)
-			
-			store.merge({[item]: undefined});
-			cleanedExpected.push(item);
-			passTime()
-			assertBody(current.map(s => s+'{}').join(' '))
-			assertEqual(cleaned, cleanedExpected)
-		}
-	})
-
-	it(`removes an entire object and calls cleaners`, () => {
-		let cleaned = {};
-		let store = new Store({b:2,c:3,a:1})
-		let cnt = 0
-		mount(document.body, () => {
-			if (store.getType()==="object") {
-				store.onEach(item => {
-					cnt++
-					node(item.index())
-					clean(() => {
-						cleaned[item.index()] = true;
-					})
-				})
-			} else {
-				text(JSON.stringify(store.get()))
-			}
-		})
-		assertBody(`a{} b{} c{}`)
-		
-		store.set(true)
-		passTime()
-		assertBody(`"true"`)
-		assertEqual(cleaned, {a:true, b:true, c:true})
-		assertEqual(cnt, 3)
-	})
-
-	it('should ignore on delete followed by set', () => {
-		let store = new Store({a:1, b:2})
-		let cnt = 0
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-				cnt++
-			})
-		})
-		assertBody(`a{} b{}`)
-		assertEqual(cnt, 2)
-
-		store.delete('a')
-		assertEqual(store.get(), {b: 2})
-		store.set('a', 3)
-		passTime()
-		assertBody(`a{} b{}`)
-		assertEqual(cnt, 2) // should not trigger again as the value is not subscribed
-	});
-
-	it('should do nothing on set followed by delete', () => {
-		let store = new Store({a:1})
-		let cnt = 0
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-				cnt++
-			})
-		})
-		assertBody(`a{}`)
-		assertEqual(cnt, 1)
-
-		store.set('b', 2)
-		assertEqual(store.get(), {a: 1, b: 2})
-		store.delete('b')
-		passTime()
-		assertBody(`a{}`)
-		assertEqual(cnt, 1)
-	})
-
-	it(`should handle items with identical sort keys`, () => {
-		let store = new Store({a: 1, b: 1, c: 1, d: 1})
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-			}, item => item.getNumber())
-		})
-		assertEqual(getBody().split(' ').sort().join(' '), `a{} b{} c{} d{}`)
-
-		store.delete('b')
-		passTime()
-		assertEqual(getBody().split(' ').sort().join(' '), `a{} c{} d{}`)
-
-		store.delete('d')
-		passTime()
-		assertEqual(getBody().split(' ').sort().join(' '), `a{} c{}`)
-
-		store.delete('a')
-		passTime()
-		assertEqual(getBody().split(' ').sort().join(' '), `c{}`)
-
-	})
-
-	it('keeps two onEaches in order', () => {
-		let store1 = new Store(['c1'])
-		let store2 = new Store(['c2'])
-		mount(document.body, () => {
-			store1.onEach(item => {
-				node(item.getString())
-			})
-			store2.onEach(item => {
-				node(item.getString())
-			}, item => item.getString())
-		})
-		assertBody(`c1{} c2{}`)
-		
-		store1.set(1, 'b1')
-		passTime()
-		assertBody(`c1{} b1{} c2{}`)
-
-		store2.set(['b2', 'c2', 'd2'])
-		passTime()
-		assertBody(`c1{} b1{} b2{} c2{} d2{}`)
-
-		store1.set([])
-		passTime()
-		assertBody(`b2{} c2{} d2{}`)
-
-		store2.set([])
-		passTime()
-		assertBody(``)
-
-		store2.set(['c2', 'b2'])
-		passTime()
-		assertBody(`b2{} c2{}`)
-
-		store1.set(['c1', 'b1'])
-		passTime()
-		assertBody(`c1{} b1{} b2{} c2{}`)
-	})
-	
-	it(`iterates arrays`, () => {
-		let store = new Store(['e', 'b', 'a', 'd'])
-		mount(document.body, () => {
-			store.onEach(item => {
-				node('h'+item.index())
-			})
-			store.onEach(item => {
-				node('i'+item.index())
-			}, item => item.getString())
-		})
-
-		assertBody(`h0{} h1{} h2{} h3{} i2{} i1{} i3{} i0{}`)
-
-		store.set(4,'c')
-
-		passTime()
-		assertBody(`h0{} h1{} h2{} h3{} h4{} i2{} i1{} i4{} i3{} i0{}`)
-	})
-
-	it(`iterates arrays that are pushed into`, () => {
-		let store = new Store(['e', 'b', 'a', 'd'])
-		mount(document.body, () => {
-			store.onEach(item => {
-				node('h'+item.index())
-			})
-			store.onEach(item => {
-				node('i'+item.index())
-			}, item => item.getString())
-		})
-
-		store.push('c')
-		
-		passTime()
-		assertBody(`h0{} h1{} h2{} h3{} h4{} i2{} i1{} i4{} i3{} i0{}`) 
-	})
-
-	it(`removes all children before redrawing`, () => {
-		let store = new Store({a:1, b:2})
-		let select = new Store(1)
-		mount(document.body, () => {
-			select.get();
-			store.onEach(item => {
-				node(item.index())
-			}, item => {
-				if (select.get() == item.get()) {
-					return item.index();
-				}
-			})
-		})
-		assertBody(`a{}`) 
-
-		select.set('2')
-		passTime()
-		assertBody(`b{}`) 
-	})
-
-	it('should handle items that don\'t create DOM elements', () => {
-		let store = new Store("b0 b1 c1 b2 c0 a1 a0 a2".split(" "))
-		mount(document.body, () => {
-			store.onEach(item => {
-				let letter = item.get()[0]
-				let count = 0 | item.get()[1]
-				for(let i=0; i<count; i++) {
-					text(item.index()+letter)
-				}
-			}, item => item.get()[0])
-		})
-		assertBody(`"7a" "7a" "5a" "3b" "3b" "1b" "2c"`) // The order within the same letter is unspecified
-
-		store.set(5, undefined)
-		store.set(3, undefined)
-		passTime()
-		assertBody(`"7a" "7a" "1b" "2c"`) // The order within the same letter is unspecified
-
-		store.set(0, undefined)
-		store.set(4, undefined)
-		store.set(6, undefined)
-		passTime()
-		assertBody(`"7a" "7a" "1b" "2c"`) // The order within the same letter is unspecified
-	})
-
-	it('filters when there is no sort key', () => {
-		let store = new Store(['a','b','c'])
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.get())
-			}, item => item.get()=='b' ? undefined : item.get())
-		})
-		assertBody(`a{} c{}`)
-		
-		store.set([])
-		passTime()
-		assertBody(``)
-	})
-})

package/tests/prediction.js

@@ -1,97 +0,0 @@
-describe('Prediction', function() {
-
-    it('reverts', () => {
-        let store = new Store('a')
-		mount(document.body, () => {
-            node(store.get())
-		})
-		assertBody(`a{}`)
-
-        let prediction = applyPrediction(() => store.set('b'))
-        passTime()
-		assertBody(`b{}`)
-
-        applyCanon(undefined, [prediction])
-        passTime()
-		assertBody(`a{}`)
-
-        // Doing this again shouldn't break anything
-        applyCanon(undefined, [prediction])
-        passTime()
-		assertBody(`a{}`)
-    });
-
-    it('reverts entire patch when it can no longer apply', () => {
-        let store = new Store({1: 'a', 2: 'x', 3: 'm'})
-		mount(document.body, () => {
-            node(store.get(1))
-            node(store.get(2))
-            node(store.get(3))
-		})
-		assertBody(`a{} x{} m{}`)
-
-        // This prediction should be flushed out due to conflict
-        applyPrediction(() => store.merge({1: 'b', 2: 'y'}))
-        passTime()
-		assertBody(`b{} y{} m{}`)
-
-        // This prediction should be kept
-        applyPrediction(() => store.set(3, 'n'))
-        passTime()
-		assertBody(`b{} y{} n{}`)
-
-        // Create the conflict
-        applyCanon(() => {
-            // Check that state was reverted to pre-predictions
-            assertEqual(store.get(1), 'a')
-            store.set(1, 'c')
-        })
-
-        // Check that only the first prediction has been reverted as a whole
-        passTime()
-		assertBody(`c{} x{} n{}`)
-    });
-
-    it('forcibly reverts to canon state', () => {
-        let store = new Store('a')
-		mount(document.body, () => {
-            node(store.get())
-		})
-		assertBody(`a{}`)
-
-        let prediction = applyPrediction(() => store.set('b'))
-        passTime()
-		assertBody(`b{}`)
-
-        store.set('z')
-
-        applyCanon(undefined, [prediction])
-
-        // An error should be thrown asynchronously
-        assertThrow('Error', () => {
-            passTime()
-        })
-		assertBody(`a{}`)
-    })
-
-    it('does not cause redraw when it comes true', () => {
-        let store = new Store('a')
-        let draws = 0
-		mount(document.body, () => {
-            node(store.get())
-            draws++
-		})
-		assertBody(`a{}`)
-        assertEqual(draws, 1)
-
-        let prediction = applyPrediction(() => store.set('b'))
-        passTime()
-		assertBody(`b{}`)
-        assertEqual(draws, 2)
-
-        applyCanon(() => store.set('b'), [prediction])
-        passTime()
-		assertBody(`b{}`)
-        assertEqual(draws, 2)
-    })
-})

package/tests/props.js

@@ -1,49 +0,0 @@
-describe('Props', function() {
-    it('Sets and unsets classes', () => {
-        let cnt1 = 0, cnt2 = 0, cnt3 = 0
-        let classObj = new Store({a: false, b: true, c: undefined})
-        mount(document.body, () => {
-            cnt1++
-            node('div', () => {
-                cnt2++
-                observe(() => {
-                    cnt3++
-                    prop({class: classObj.get()})
-                })
-            })
-        })
-
-        passTime()
-        assertBody(`div{@class="b"}`)
-
-        classObj.merge({a: true, d: true})
-        passTime()
-        assertBody(`div{@class="a b d"}`)
-
-        classObj.merge({a: null}) // Removed from div
-        classObj.delete('b') // Won't disappear
-        passTime()
-        assertBody(`div{@class="b d"}`)
-
-        assertEqual([cnt1,cnt2,cnt3], [1,1,3])
-    })
-
-    it('Defines and removes event listeners', () => {
-        let store = new Store(true)
-        let el;
-        let myFunc = ()=>{}
-        mount(document.body, () => {
-            node('div', () => {
-                el = getParentElement()
-                if (store.get()) prop({click: myFunc})
-            })
-        })
-
-        passTime()
-        assertEqual(el.events, {click: new Set([myFunc])})
-
-        store.set(false)
-        passTime()
-        assertEqual(el.events, {click: new Set()})
-    })
-})

package/tests/schedule.js

@@ -1,44 +0,0 @@
-describe('DOM read/write scheduler', function() {
-
-    it('orders in batches', () => {
-        let order = ''
-        let store = new Store('a')
-		mount(document.body, () => {
-            node(store.get())
-            order += store.get()
-		})
-        scheduleDomReader(() => order += 'r1')
-        scheduleDomWriter(() => order += 'w1')
-        scheduleDomReader(() => order += 'r2')
-        scheduleDomWriter(() => order += 'w2')
-        store.set('b')
-        scheduleDomReader(() => order += 'r3')
-        scheduleDomWriter(() => order += 'w3')
-        scheduleDomReader(() => order += 'r4')
-        scheduleDomWriter(() => {
-            order += 'w4'
-            scheduleDomReader(() => {
-                order += 'R1'
-                scheduleDomReader(() => order += 'R2')
-                scheduleDomWriter(() => order += 'W1')
-            })
-        })
-        scheduleDomReader(() => order += 'r5')
-        scheduleDomWriter(() => order += 'w5')
-        
-		assertBody(`a{}`)
-        assertEqual(order, 'a')
-
-        passTime()
-
-		assertBody(`b{}`)
-        assertEqual(order, 'abr1r2r3r4r5w1w2w3w4w5R1R2W1')
-
-        order = ''
-        scheduleDomWriter(() => order += 'W')
-        scheduleDomReader(() => order += 'R')
-        passTime()
-        assertEqual(order, 'RW')
-    });
-
-})