aberdeen 0.2.1 → 0.2.2

package/tests/destroy.js

@@ -1,270 +0,0 @@
-describe('Destroy event', function() {
-	it('works for simple deletes', () => {
-        let store = new Store(true)
-		mount(document.body, () => {
-            if (store.get()) node('b', {destroy: "x"})
-            else node('c', {destroy: "x"})
-		})
-		assertBody(`b{}`)
-        assertEqual(getCounts(), {new: 1, change: 1})
-
-        store.set(false)
-        passTime(1)
-		assertBody(`c{} b{@class="x"}`)
-        assertEqual(getCounts(), {new: 2, change: 3})
-
-        passTime(5000)
-		assertBody(`c{}`)
-        assertEqual(getCounts(), {new: 2, change: 4})
-    });
-
-	it('inserts before deleted item', () => {
-        let store = new Store(['a'])
-		mount(document.body, () => {
-            store.onEach(v => {
-                node(v.get(), {destroy: "x"})
-            })
-		})
-
-        store.set([undefined])
-        passTime(1)
-		assertBody(`a{@class="x"}`)
-
-        store.set(['b'])
-        passTime(1)
-		assertBody(`b{} a{@class="x"}`)
-
-        passTime(2000)
-		assertBody(`b{}`)
-    });
-
-	it('transitions onEach deletes', () => {
-        let store = new Store(['a', 'b', 'c'])
-		let mnt = mount(document.body, () => {
-            store.onEach(v => {
-                node(v.get(), {destroy: "x"})
-            })
-		})
-		assertBody(`a{} b{} c{}`)
-        assertEqual(getCounts(), {new: 3, change: 3})
-
-        store.set(1, undefined)
-        passTime(1)
-		assertBody(`a{} b{@class="x"} c{}`)
-        passTime(2000)
-		assertBody(`a{} c{}`)
-
-        store.set(['a', 'b', 'c', 'd', 'e', 'f'])
-        passTime(1)
-        store.set([undefined, 'b', undefined, undefined, 'e', undefined])
-        passTime(1)
-		assertBody(`a{@class="x"} b{} c{@class="x"} d{@class="x"} e{} f{@class="x"}`)
-        store.set(['a2', 'b', undefined, 'd2', 'e', 'f2'])
-        passTime(1)
-		assertBody(`a2{} a{@class="x"} b{} d2{} c{@class="x"} d{@class="x"} e{} f2{} f{@class="x"}`)
-        passTime(2000)
-		assertBody(`a2{} b{} d2{} e{} f2{}`)
-    })
-
-    it('deletes in the middle of deleting items', () => {
-        let store = new Store(['a', 'b', 'c'])
-		mount(document.body, () => {
-            store.onEach(v => {
-                node(v.get(), {destroy: "x"})
-            })
-		})
-        passTime(1)
-        assertBody(`a{} b{} c{}`)
-
-        store.set(2, undefined)
-        passTime(500)
-        assertBody(`a{} b{} c{@class="x"}`)
-        store.set(1, undefined)
-        passTime(500)
-        assertBody(`a{} b{@class="x"} c{@class="x"}`)
-        store.set(0, undefined)
-        passTime(500)
-        assertBody(`a{@class="x"} b{@class="x"} c{@class="x"}`)
-        passTime(500)
-        assertBody(`a{@class="x"} b{@class="x"}`)
-        passTime(500)
-        assertBody(`a{@class="x"}`)
-        passTime(500)
-        assertBody(``)
-
-        store.set([undefined, 'b'])
-        passTime(1)
-        assertBody(`b{}`)
-    });
-
-    it('aborts deletion transition on higher level removal', () => {
-        let store = new Store(['a'])
-		mount(document.body, () => {
-            store.onEach(v => {
-                node(v.get(), {destroy: "x"})
-            })
-		})
-        passTime(1)
-        assertBody(`a{}`)
-
-        store.set([])
-        passTime(1)
-        assertBody(`a{@class="x"}`)
-        store.set(undefined)
-        passTime(2001)
-        assertBody(``)
-
-        // what happens when the whole store is removed?
-        // the held elements should be removed immediately... are they? and does the timeout then cause havoc?
-    });
-
-    it('transitions removal of an entire onEach', () => {
-        let store = new Store(['a'])
-		mount(document.body, () => {
-            store.onEach(v => {
-                node(v.get(), {destroy: "x"})
-            })
-		})
-        passTime(1)
-        assertBody(`a{}`)
-        store.set(undefined)
-        passTime(1000)
-        assertBody(`a{@class="x"}`)
-        passTime(1000)
-        assertBody(``)
-    });
-
-    it('insert new elements after a recently deleted item', () => {
-        let store = new Store({b: true, c: false})
-		mount(document.body, () => {
-            node('a')
-            observe(() => {
-                if (store.get('b')) node('b', {destroy: 'y'})
-                if (store.get('c')) node('c')
-            })
-		})
-        assertBody(`a{} b{}`)
-
-        store.set('b', false)
-        passTime(1)
-        assertBody(`a{} b{@class="y"}`)
-
-        passTime(2000)
-        assertBody(`a{}`)
-
-        // This should trigger lazy deletion of the DeletionScope
-        store.set('c', true)
-        passTime(1)
-        assertBody(`a{} c{}`)
-    })
-
-    it('remove elements before and after a deleting element', () => {
-        let store = new Store({a: true, b: true, c: true})
-		mount(document.body, () => {
-            store.onEach(el => {
-                if (el.get()) node(el.index(), el.index()=='b' ? {destroy: 'y'}: null)
-            })
-		})
-        assertBody(`a{} b{} c{}`)
-
-        store.set('b', false)
-        passTime(1)
-        assertBody(`a{} b{@class="y"} c{}`)
-
-        store.set('a', false)
-        passTime(1)
-        assertBody(`b{@class="y"} c{}`)
-
-        store.set('c', false)
-        passTime(1)
-        assertBody(`b{@class="y"}`)
-
-        passTime(2000)
-        assertBody(``)
-    })
-
-    it('remove middle elements before and after a deleting element', () => {
-        let store = new Store({a: true, b: true, c: true, d: true, e: true})
-		mount(document.body, () => {
-            store.onEach(el => {
-                if (el.get()) node(el.index(), el.index()=='c' ? {destroy: 'y'}: null)
-            })
-		})
-        assertBody(`a{} b{} c{} d{} e{}`)
-
-        store.set('c', false)
-        passTime(1)
-        assertBody(`a{} b{} c{@class="y"} d{} e{}`)
-
-        store.set('b', false)
-        passTime(1)
-        assertBody(`a{} c{@class="y"} d{} e{}`)
-
-        store.set('d', false)
-        passTime(1)
-        assertBody(`a{} c{@class="y"} e{}`)
-
-        passTime(2000)
-        assertBody(`a{} e{}`)
-    })
-
-    it('remove elements before and after a deleting element', () => {
-        let store = new Store({a: true, b: true, c: true})
-		mount(document.body, () => {
-            store.onEach(el => {
-                if (el.get()) node(el.index(), el.index()=='b' ? {destroy: 'y'}: null)
-            })
-		})
-        assertBody(`a{} b{} c{}`)
-
-        store.set('b', false)
-        passTime(1)
-        assertBody(`a{} b{@class="y"} c{}`)
-
-        store.set('a', false)
-        passTime(1)
-        assertBody(`b{@class="y"} c{}`)
-
-        store.set('c', false)
-        passTime(1)
-        assertBody(`b{@class="y"}`)
-
-        passTime(2000)
-        assertBody(``)
-    })
-
-    it('performs a shrink animation', () => {
-        let store = new Store(true)
-        mount(document.body, () => {
-            if (store.get()) node('a', {destroy: shrink})
-        })
-
-        assertBody(`a{}`)
-        
-        store.set(false)
-        passTime(1)
-        assert(getBody().startsWith('a{'))
-        assert(getBody().indexOf('scaleY')>=0 && getBody().indexOf('scaleX')<0)
-        passTime(2000)
-        assertBody(``)
-    })
-
-    it('performs a horizontal shrink animation', () => {
-        let store = new Store(true)
-        mount(document.body, () => {
-            node('div', {style: {display: 'flex', flexDirection: 'row-reverse'}}, () => {
-                if (store.get()) node('a', {destroy: shrink})
-            })
-        })
-
-        assertBody(`div{:display="flex" :flexDirection="row-reverse" a{}}`)
-        
-        store.set(false)
-        passTime(1)
-        assert(getBody().indexOf('scaleX')>=0 && getBody().indexOf('scaleY')<0)
-
-        passTime(2000)
-        assertBody(`div{:display="flex" :flexDirection="row-reverse"}`)
-    })
-
-})

package/tests/dom.js

@@ -1,219 +0,0 @@
-describe('DOM creator', function() {
-	it('adds nodes', () => {
-		mount(document.body, () => {
-			node('p')
-		})
-		passTime();
-		assertBody(`p{}`)
-	});
-
-	it('adds classes', () => {
-		mount(document.body, () => {
-			node('p.a.b')
-		})
-		passTime();
-		assertBody(`p{@class="a b"}`)
-	});
-
-	it('sets attributes', () => {
-		mount(document.body, () => {
-			node('div', {class: 'C', text: "T"}, {id: 'I', index: 1})
-		})
-		passTime();
-		assertBody(`div{@class="C" @id="I" @index="1" "T"}`)
-	});
-
-	it('sets properties', () => {
-		mount(document.body, () => {
-			node('p', {className: 'C', value: 3})
-		})
-		passTime();
-		assertBody(`p{@class="C" value=3}`)
-	});
-
-	it('nests elements', () => {
-		mount(document.body, () => {
-			node('p', () => {
-				node('a', () => {
-					node('i', () => {
-						text('contents')
-					})
-				})
-			})
-		})
-		passTime();
-		assertBody(`p{a{i{"contents"}}}`)
-	});
-
-	it('sets properties from the inner scope', () => {
-		mount(document.body, () => {
-			node('a', () => {
-				prop('href', '/')
-				prop({
-					target: '_blank',
-					disabled: true,
-				})
-			})
-		})
-		passTime();
-		assertBody(`a{@href="/" @target="_blank" disabled=true}`)
-	});
-
-	it('sets style objects', () => {
-		mount(document.body, () => {
-			node('a', {style: 'color: red;'})
-			node('b', {style: {color: 'green'}})
-			node('c', () => {
-				prop({style: {color: 'orange'}})
-			})
-			node('d', () => {
-				prop('style', {color: 'purple'})
-			})
-			node('e', () => {
-				prop('style', 'color: magento;')
-			})
-			node('f', () => {
-				prop({style: 'color: cyan;'})
-			})
-
-		})
-		assertBody(`a{@style="color: red;"} b{:color="green"} c{:color="orange"} d{:color="purple"} e{@style="color: magento;"} f{@style="color: cyan;"}`)
-	})
-
-	it('unmounts', () => {
-		let store = new Store('Hej world')
-		let cnt = 0
-		mount(document.body, () => {
-			cnt++
-			node('p', store.get())
-		})
-		assertBody(`p{"Hej world"}`)
-
-		unmount()
-		assertBody(``)
-
-		store.set('Updated')
-		passTime()
-		assertEqual(cnt, 1)
-	})
-
-	it('creates text nodes', () => {
-		let index = new Store(0)
-		let cases = [
-			['test', `"test"`],
-			['', `""`],
-			[0, `"0"`],
-			[null, ``],
-			[undefined, ``],
-			[false, `"false"`],
-		]
-		mount(document.body, () => {
-			text(cases[index.get()][0])
-		})
-
-		while(true) {
-			passTime()
-			assertBody(cases[index.peek()][1])
-			if (index.peek() >= cases.length-1) {
-				break
-			}
-			index.set(index.peek()+1)
-		}
-	})
-
-	it('adds preexisting elements to the DOM', () => {
-		mount(document.body, () => {
-			let el = document.createElement('video')
-			el.classList.add("test")
-			node(el)
-		})
-		assertBody(`video{@class="test"}`)
-	})
-
-	it('handles nontypical options well', () => {
-		let cases = [
-			[`div{}`, () => node("")],
-			[`div{}`, () => node(".")],
-			[`div{@class="a b c"}`, () => node(".a.b.c")],
-			[`div{"1234"}`, () => node(undefined, 1234)],
-			[`_!@#*{"replacement"}`, () => node("_!@#*", null, undefined, {}, "original", 1234, "replacement")],
-		]
-		for(let c of cases) {
-			mount(document.body, () => {
-				c[1]()
-			})
-			assertBody(c[0])
-			unmount()
-		}
-		mount(document.body, () => {
-			assertThrow("Unexpected argument", () => node("span", []))
-			assertThrow("Unexpected argument", () => node("span", new Error()))
-			assertThrow("Unexpected argument", () => node("span", true))
-		})
-	})
-
-	it('dumps all basic values', () => {
-		let store = new Store([true,false,null,undefined,-12,3.14,"test",'"quote"'])
-		mount(document.body, () => store.dump())
-		assertBody(`"<array>" ul{li{"0: " "true"} li{"1: " "false"} li{"2: " "null"} li{"4: " "-12"} li{"5: " "3.14"} li{"6: " "\\"test\\""} li{"7: " "\\"\\\\\\"quote\\\\\\"\\""}}`)
-	})
-
-	it('dumps maps, objects and arrays', () => {
-		let store = new Store(new Map([[3,4],['a','b']]))
-		mount(document.body, () => store.dump())
-		assertBody(`"<map>" ul{li{"\\"a\\": " "\\"b\\""} li{"3: " "4"}}`)
-		
-		store.set({3: 4, a: 'b'})
-		passTime()
-		assertBody(`"<object>" ul{li{"\\"3\\": " "4"} li{"\\"a\\": " "\\"b\\""}}`)
-		
-		store.set([4, undefined, 'b'])
-		passTime()
-		assertBody(`"<array>" ul{li{"0: " "4"} li{"2: " "\\"b\\""}}`)
-	})
-
-	it('adds html', () => {
-		let store = new Store('test')
-		mount(document.body, () => {
-			node('main', () => {
-				node('hr')
-				observe(() => {
-					html(store.get())
-				})
-				node('img')
-			})
-		})
-		assertBody(`main{hr{} fake-emulated-html{"test"} img{}}`)
-
-		store.set("")
-		passTime()
-		assertBody(`main{hr{} img{}}`)
-
-		store.set(123)
-		passTime()
-		assertBody(`main{hr{} fake-emulated-html{"123"} img{}}`)
-
-		assertThrow("Operation not permitted outside of a mount() scope", () => html("test"))
-		observe(() => {
-			assertThrow("Operation not permitted outside of a mount() scope", () => html("test"))
-		})
-	})
-
-	it('only unlinks the top parent of the tree being removed', () => {
-		let store = new Store(true)
-		mount(document.body, () => {
-			if (store.get()) node('main', () => {
-				node('a')
-				node('b')
-				node('c')
-			})
-		})
-		assertBody(`main{a{} b{} c{}}`)
-		assertEqual(getCounts(), {new: 4, change: 4})
-
-		store.set(false)
-		passTime()
-		assertBody(``)
-		assertEqual(getCounts(), {new: 4, change: 5})
-	})
-});

package/tests/errors.js

@@ -1,114 +0,0 @@
-describe('Error handling', () => {
-	it('continues rendering after an error', () => {
-        let error = new Store(false)
-        mount(document.body, () => {
-            node('a', () => {
-                node('b')
-                if (error.get()) {
-                    throw Error('FakeError')
-                }
-                node('c')
-            })
-            node('d')
-        })
-        passTime()
-		assertBody(`a{b{} c{}} d{}`)
-        error.set(true)
-        assertThrow('FakeError', passTime)
-        assertBody(`a{b{}} d{}`)
-    })
-
-
-    it('throws when doing DOM operations outside of mount', () => {
-		let ops = [
-			() => node('div'),
-			() => text('hi'),
-			() => prop('hi'),
-            () => getParentElement(),
-		]
-		for(let op of ops) {
-			assertThrow('outside of a mount', op)
-		}
-        assertThrow(() => clean(()=>"test"))
-
-		observe(() => {
-			for(let op of ops) {
-				assertThrow('outside of a mount', op)
-			}	
-		})
-	})
-
-
-    it('continue rendering after an error in onEach', () => {
-        let store = new Store(['a','b','c'])
-        mount(document.body, () => {
-            store.onEach(item => {
-                if (item.index()%2) noSuchFunction()
-                text(item.get())
-            })
-        })
-        assertThrow(passTime)
-        assertBody(`"a" "c"`)
-
-        store.push('d')
-        store.push('e')
-        assertThrow(passTime)
-        assertBody(`"a" "c" "e"`)
-    })
-
-    it('continue rendering after an error in onEach sort', () => {
-        let store = new Store(['a','b','c'])
-        mount(document.body, () => {
-            store.onEach(item => {
-                text(item.get())
-            }, item => {
-                if (item.index()%2) noSuchFunction()
-                return -item.index()
-            })
-        })
-        assertThrow(passTime)
-        assertBody(`"c" "a"`)
-
-        store.push('d')
-        store.push('e')
-        assertThrow(passTime)
-        assertBody(`"e" "c" "a"`)
-    })
-
-    it('throws when indexing a non-indexable type', () => {
-        let store = new Store(3)
-        assertThrow('Value 3 is not a collection', () => store.ref('a'))
-        assertThrow('Value 3 is not a collection', () => store.makeRef('a'))
-    })
-
-    it('throws when onEach() is invoked wrong', () => {
-        let store1 = new Store()
-        let store2 = new Store()
-        assertThrow('Operation not permitted outside', () => store1.onEach(item=>{}))
-        store1.set(5)
-        observe(() => {
-            assertThrow('neither a collection nor undefined', () => store1.onEach(item=>{}))
-            assertThrow('function as its last argument', () => store1.onEach())
-
-            store2.onEach('a', 3, true, item => {
-                assert(false, "Should not be invoked")
-            })
-        })
-        passTime()
-    })
-
-    it('throws when passing invalid Store arguments', () => {
-        assertThrow('1st parameter should be an ObsCollection', () => new Store(3, true))
-    })
-
-    it('breaks up long update->observe recursions', () => {
-        let store = new Store({a: 0, b: 0})
-        observe(() => {
-            store.set('a', store.get('b')+1)
-        })
-        observe(() => {
-            store.set('b', store.get('a')+1)
-        })
-        assertThrow('recursive', passTime)
-    })
-})

package/tests/immediate.js

@@ -1,87 +0,0 @@
-describe('Immediate observe', function() {
-
-    it('runs immediately', () => {
-        let store = new Store({a: 1})
-        let count = 0
-        immediateObserve(() => {
-            store.set('b', store.get('a') * 2)
-            count++
-        })
-        assertEqual(store.get('b'), 2)
-        assertEqual(count, 1)
-
-        store.set('a', 3)
-        assertEqual(store.get('b'), 6)
-        assertEqual(count, 2)
-
-        passTime() // shouldn't change anything
-        assertEqual(store.get('b'), 6)
-        assertEqual(count, 2)
-    });
-
-    it('stabilizes dependent values', () => {
-        let store = new Store({num: 1})
-        immediateObserve(() => { // num to str
-            let num = store.get("num")
-            if (typeof num === 'number') {
-                store.set('str', "x".repeat(num))
-            } else {
-                store.set('num', 0) // will call this observer recursively
-            }
-        })
-        immediateObserve(() => {  // str to num
-            let str = store.get('str')
-            if (typeof str === 'string') {
-                store.set('str', "x".repeat(str.length)) // replace str chars by 'x'
-                store.set('num', str.length) // may call this observer recursively
-            } else {
-                store.set('str', "") // will call this observer recursively
-            }
-        })
-        assertEqual(store.get(), {num: 1, str: 'x'})
-
-        store.set('num', 3)
-        assertEqual(store.get(), {num: 3, str: 'xxx'})
-
-        store.set('num', '')
-        assertEqual(store.get(), {num: 0, str: ''})
-
-        store.set('str', 'af123')
-        assertEqual(store.get(), {num: 5, str: 'xxxxx'})
-    })
-
-    it('stops when it goes out of scope', () => {
-        let store = new Store({a: 1})
-        observe(() => {
-            if (store.get('stop')) return
-            immediateObserve(() => {
-                store.set('b', store.get('a') * 2)
-            })
-        })
-        assertEqual(store.get('b'), 2)
-
-        store.set('a', 3)
-        assertEqual(store.get('b'), 6)
-
-        store.set('stop', true)
-        passTime() // allow the deferred observe to rerun, expiring the immediate observe
-
-        store.set('a', 5)
-        assertEqual(store.get('b'), 6)
-    })
-
-    it('throws an error if a loop does not stabilize', () => {
-        let store = new Store({a: 1})
-        immediateObserve(() => {
-            store.set('b', store.get('a') + 1)
-        })
-        // This will start an infinite recursion, which should be broken up.
-        immediateObserve(() => { 
-            store.set('a', store.get('b') + 1)
-        })
-        // The error for the above is to be thrown async.
-        assertThrow('recursive updates', () => {
-            passTime()
-        })
-    })
-})