aberdeen 0.2.1 → 0.2.3

package/tests/_fakedom.js

@@ -1,255 +0,0 @@
-let insertedCss = '';
-
-global.document = {
-	createElement: tag => new Element(tag),
-	createTextNode: text => new TextNode(text),
-	head: {
-		appendChild: function(el) {
-			if (el.tag!=='style') {
-				throw new Error("only <style> inserts in head can be emulated");
-			}
-			insertedCss += el.innerText;
-		}
-	}
-};
-global.window = {};
-
-
-let newCount = 0, changeCount = 0;
-global.resetCounts = function() { newCount = changeCount = 0; };
-global.getCounts = function() { return {new: newCount, change: changeCount}; };
-
-let timeouts = [];
-let currentTime = 0;
-
-global.setTimeout = function(func,time) {
-	timeouts.push({func, time: time+currentTime});
-};
-
-global.passTime = function(ms) {
-	let targetTime = ms==null ? undefined : currentTime + ms;
-	while(timeouts.length) {
-		// Find the timeout that should occur first
-		let smallestIdx = 0;
-		for(let idx=1; idx<timeouts.length; idx++) {
-			if (timeouts[idx].time < timeouts[smallestIdx].time) smallestIdx = idx;
-		}
-		let timeout = timeouts[smallestIdx];
-		// If this timeout is not due yet, we're done
-		if (targetTime!=null && timeout.time > targetTime) break;
-		// Timeout is due! Remove it from the list, update the currentTime, and fire the callback!
-		timeouts.splice(smallestIdx, 1);
-		currentTime = timeout.time;
-		timeout.func();
-	}
-	currentTime = targetTime==null ? 0 : targetTime
-}
-
-
-class Node {
-	get nextSibling() {
-		return this.getSibling(+1);
-	}
-	get previousSibling() {
-		return this.getSibling(-1);
-	}
-	getSibling(delta) {
-		if (!this.parentNode) return;
-		let siblings = this.parentNode.childNodes;
-		let idx = siblings.indexOf(this);
-		if (idx < 0) throw new Error("not part of siblings!?");
-		return siblings[idx+delta];
-	}
-}
-
-class Element extends Node {
-	constructor(tag) {
-		super();
-		this.tag = tag;
-		this.childNodes = [];
-		this._style = {};
-		this.attrs = {};
-		this.events = {};
-		newCount++;
-	}
-	appendChild(node) {
-		this.insertBefore(node, null);
-	}
-	insertBefore(node, ref) {
-		if (node.parentNode) node.parentNode.removeChild(node);
-		else changeCount++;
-		node.parentNode = this;
-		if (ref) {
-			let idx = this.childNodes.indexOf(ref);
-			if (idx<0) throw new Error("non-existing ref node");
-			this.childNodes.splice(idx, 0, node);
-		} else {
-			this.childNodes.push(node);
-		}
-	}
-	removeChild(node) {
-		let idx = this.childNodes.indexOf(node);
-		if (idx<0) throw new Error("no such child");
-		this.childNodes.splice(idx, 1);
-		node.parentNode = null;
-		changeCount++;
-	}
-	remove() {
-		this.parentNode.removeChild(this);
-	}
-	replaceChild(newNode, oldNode) {
-		this.insertBefore(newNode, oldNode);
-		this.removeChild(oldNode);
-	}
-	setAttribute(k, v) {
-		this.attrs[k] = ''+v;
-		changeCount++;
-	}
-	getAttribute(k) {
-		return this.attrs[k]
-	}
-	removeAttribute(k) {
-		delete this.attrs[k];
-		changeCount++;
-	}
-	get classList() {
-		return {
-			add: name => {
-				let set = this._getClassSet();
-				set.add(name);
-				this._setClassSet(set);
-				changeCount++;
-			},
-			remove: name => {
-				let set = this._getClassSet();
-				set.delete(name);
-				this._setClassSet(set);
-				changeCount++;
-			},
-		}
-	}
-	get parentElement() {
-		if (this.parentNode instanceof Element) return this.parentNode;
-	}
-	_getClassSet() {
-		return new Set(this.attrs.class ? this.attrs.class.split(' ') : []);
-	}
-	_setClassSet(map) {
-		this.attrs.class = Array.from(map).sort().join(' ');
-		if (!this.attrs.class) delete this.attrs.class;
-	}
-	get firstChild() {
-		return this.childNodes[0];
-	}
-	get lastChild() {
-		return this.childNodes[this.childNodes.length-1];
-	}
-	set style(val) {
-		if (val !== '') throw new Error("non-empty style string cannot be emulated");
-		this._style = {};
-		changeCount++;
-	}
-	set textContent(text) {
-		this.childNodes = [new TextNode(text)];
-	}
-	set innerHTML(html) {
-		this.childNodes = [];
-		if (html) {
-			let n = new Element('fake-emulated-html');
-			n.textContent = html;
-			this.appendChild(n);
-		}
-	}
-	get style() {
-		for(let k in this._style) {
-			if (this._style[k] === '') delete this._style[k];
-		}
-		return this._style;
-	}
-	set className(v) {
-		this.attrs.class = v;
-		changeCount++;
-	}
-	get offsetHeight() {
-		return 20;
-	}
-	get offsetWidth() {
-		return 200;
-	}
-	toString() {
-		let props = Object.assign({}, this);
-		for(let k in this.attrs) props['@'+k] = this.attrs[k];
-		for(let k in this.style) props[':'+k] = this._style[k];
-		delete props.tag;
-		delete props.attrs;
-		delete props._style;
-		delete props.events;
-		delete props.childNodes;
-		delete props.parentNode;
-
-		let arr = [];
-		for(let k in props) arr.push(k+'='+JSON.stringify(props[k]));
-		arr.sort();
-		for(let child of this.childNodes) arr.push(child.toString());
-
-		return this.tag + `{${arr.join(' ')}}`;
-	}
-
-	addEventListener(name, func) {
-		this.events[name] = this.events[name] || new Set();
-		this.events[name].add(func);
-		changeCount++;
-	}
-	removeEventListener(name, func) {
-		if (this.events[name]) {
-			if (this.events[name].delete(func)) {
-				changeCount++
-			}
-		}
-	}
-	event(info) {
-		if (typeof info === 'string') info = {type: info};
-		let type = info.type;
-		info.target = this;
-		info.preventDefault = function(){};
-		info.stopPropagation = function(){ info.stopped = true; };
-		let node = this;
-		while(node && !info.stopped) {
-			let funcs = node.events[type];
-			if (funcs) {
-				for(let func of funcs) {
-					func.call(node, info);
-				}
-			}
-			node = node.parentNode;
-		}
-	}
-	getElementById(id) {
-		if (this.attrs.id === id) return this;
-		for(let child of this.childNodes) {
-			let el = child.getElementById(id);
-			if (el) return el;
-		}
-	}
-}
-
-class TextNode extends Node {
-	constructor(textContent) {
-		super();
-		this.textContent = '' + textContent;
-		newCount++;
-	}
-	toString() {
-		return JSON.stringify(this.textContent);
-	}
-}
-
-function getComputedStyle(el) {
-	return el._style;
-}
-
-
-global.Node = Node;
-global.TextNode = TextNode;
-global.Element = Element;
-global.getComputedStyle = getComputedStyle;

package/tests/_init.js

@@ -1,81 +0,0 @@
-import * as _ from './_fakedom.js';
-import mocha from 'mocha'
-import {deepEqual as equal} from 'fast-equals'
-
-import * as aberdeen from '../dist-min/aberdeen.js'
-import * as transitions from '../dist-min/transitions.js'
-import * as prediction from '../dist-min/prediction.js'
-Object.assign(global, aberdeen, transitions, prediction)
-
-let currentMountSeq = new Store(0)
-mocha.beforeEach(() => {
-	document.body = document.createElement('body')
-	resetCounts()
-})
-
-mocha.afterEach(() => {
-	unmount()
-	passTime(2001) // wait for deletion transitions
-	assertBody(``)
-})
-
-function toDisplay(value) {
-	if (value instanceof Map) {
-		let results = []
-		value.forEach((value,key) => results.push(JSON.stringify(key)+": "+JSON.stringify(value)))
-		return "map{" + results.join(", ") + "}"
-	} else {
-		return JSON.stringify(value)
-	}
-}
-
-global.AssertError = class extends Error {
-	constructor(text, actual, expected, expectLiteral) {
-		text += `
-		Actual:   ${toDisplay(actual)}
-		Expected: ${expectLiteral ? expected : toDisplay(expected)}`
-		super(text)
-	}
-}
-
-global.assert = function(bool, msg) {
-	if (!bool) throw new AssertError(`assert failed${msg ? ": "+msg : ""}`, bool, "something trueish", true)
-}
-
-global.assertEqual = function(actual, expected, msg) {
-	if (!equal(actual,expected)) throw new AssertError(`equal failed${msg ? ": "+msg : ""}`, actual, expected)
-}
-
-global.getBody = function() {
-	return document.body.toString().replace(/^body{/,'').replace(/}$/,'')
-}
-
-global.assertBody = function(expected) {
-	let actual = getBody()
-	if (actual !== expected) throw new AssertError(`assertBody failed`, actual, expected)
-}
-
-global.assertThrow = function(what, func) {
-	if (typeof what == 'function') {
-		func = what
-		what = undefined
-	}
-	try {
-		func()
-	} catch(e) {
-		if (what && e.toString().indexOf(what)<0) throw new AssertError(`wrong exception`, e.toString(), `something containing "${what}"`, true)
-		return
-	}
-	throw new AssertError(`exception expected`, undefined, `something containing "${what}"`, true)
-}
-
-global.objToMap = function(obj) {
-    if (typeof obj === 'object' && obj && obj.constructor===Object) {
-        let map = new Map()
-        for(let k in obj) {
-            map.set(k, objToMap(obj[k]))
-        }
-        return map
-    }
-    return obj
-}

package/tests/array.js

@@ -1,109 +0,0 @@
-describe('Array', () => {
-	it('fires higher-scope isEmpty before getting to content', () => {
-		let store = new Store(['a'])
-		let cnt1 = 0, cnt2 = 0
-		mount(document.body, () => {
-			cnt1++
-			if (!store.isEmpty()) {
-				node('div', () => {
-					cnt2++;
-					text(store.get(0))
-				})
-			}
-		})
-		assertBody(`div{"a"}`)
-
-		store.set(0, 'b')
-		passTime();
-		assertBody(`div{"b"}`)
-		assertEqual([cnt1,cnt2], [1,2])
-
-		store.delete(0);
-		passTime()
-		assertBody(``)
-		assertEqual([cnt1,cnt2], [2,2])
-	})
-
-	it('reactively get() full array', () => {
-		let store = new Store([3, 4, new Store([5, 6])])
-		mount(document.body, () => {
-			text(JSON.stringify(store.get()))
-			text(JSON.stringify(store.query({depth: 1})[2].get()))
-		})
-		passTime()
-		assertBody(`"[3,4,[5,6]]" "[5,6]"`)
-
-		store.push(7)
-		store.ref(2).push(8)
-		passTime()
-		assertBody(`"[3,4,[5,6,8],7]" "[5,6,8]"`)
-
-		assertEqual(store.get(6), undefined)
-		assertEqual(store.get(6, 'a'), undefined)
-	})
-
-	it('handles invalid indexes', () => {
-		let store = new Store(["a","b","c"])
-		for(let index in [-1, 1000000, "1", 0.5]) {
-			assertThrow('Invalid array index', () => store.set(index, "test"))
-		}
-
-		assertEqual(store.get("1"), "b")
-		assertThrow("Invalid array index", () => store.get('a'))
-		assertThrow("Invalid array index", () => store.get(true))
-	})
-
-	it('merges', () => {
-		let cnt1 = 0, cnt2 = 0
-		let store = new Store([1,undefined,3])
-		mount(document.body, () => {
-			cnt1++
-			store.onEach(item => {
-				cnt2++
-				node('div', item.get())
-			})
-		})
-
-		assertBody(`div{"1"} div{"3"}`)
-		assertEqual([cnt1, cnt2], [1,2])
-
-		store.set(1, 2)
-		passTime()
-		assertBody(`div{"1"} div{"2"} div{"3"}`)
-		assertEqual([cnt1, cnt2], [1,3])
-
-		// Merging just replace the entire array
-		store.merge([1,"two"])
-		passTime()
-		assertBody(`div{"1"} div{"two"}`)
-		assertEqual([cnt1, cnt2], [1,4])
-
-		store.set(9,'ten')
-		passTime()
-		assertBody(`div{"1"} div{"two"} div{"ten"}`)
-		assertEqual([cnt1, cnt2], [1,5])
-
-		store.set(4, 'five')
-		passTime()
-		assertBody(`div{"1"} div{"two"} div{"five"} div{"ten"}`)
-		assertEqual([cnt1, cnt2], [1,6])
-
-		store.delete(1)
-		passTime()
-		assertBody(`div{"1"} div{"five"} div{"ten"}`)
-		assertEqual([cnt1, cnt2], [1,6])
-
-		store.delete(9)
-		store.push("six")
-		assertEqual(store.get(5), "six")
-		passTime()
-		assertBody(`div{"1"} div{"five"} div{"six"}`)
-		assertEqual([cnt1, cnt2], [1,7])
-
-		store.set([1, undefined, 3])
-		passTime()
-		assertBody(`div{"1"} div{"3"}`)
-		assertEqual([cnt1, cnt2], [1,8])
-		
-	})
-})

package/tests/binding.js

@@ -1,106 +0,0 @@
-describe('Value binding', function() {
-	it('binds input values', () => {
-		let store = new Store('test')
-		let inputElement;
-		mount(document.body, () => {
-			node('input', store, () => {
-				inputElement = getParentElement()
-				prop('class', {correct: store.get().length >= 5})
-			})
-		})
-		assertBody(`input{value="test"}`)
-
-		inputElement.value = "testx"
-		inputElement.event("input")
-		passTime()
-
-		assertBody(`input{@class="correct" value="testx"}`)
-	})
-
-	it('binds checkboxes', () => {
-		let store = new Store(true)
-		let inputElement;
-		mount(document.body, () => {
-			node('input', {type: 'checkbox'}, store, () => {
-				inputElement = getParentElement()
-			})
-		})
-		assertBody(`input{@type="checkbox" checked=true}`)
-
-		inputElement.checked = false
-		inputElement.event("input")
-		passTime()
-
-		assertBody(`input{@type="checkbox" checked=false}`)
-	})
-
-	it('binds radio buttons', () => {
-		let store = new Store('woman')
-		let inputElement1, inputElement2;
-		mount(document.body, () => {
-			node('input', {type: 'radio', name: 'gender', value: 'man'}, store, () => {
-				inputElement1 = getParentElement()
-			})
-			node('input', {type: 'radio', name: 'gender', value: 'woman'}, store, () => {
-				inputElement2 = getParentElement()
-			})
-		})
-		assertBody(`input{@name="gender" @type="radio" checked=false value="man"} input{@name="gender" @type="radio" checked=true value="woman"}`)
-
-		inputElement1.checked = true
-		inputElement1.event("input")
-		inputElement2.checked = false
-		inputElement2.event("input")
-		passTime()
-
-		assertEqual(store.get(), 'man')
-	})
-
-	it('reads initial value when Store is undefined', () => {
-		let store = new Store({})
-		mount(document.body, () => {
-			node('input', {value: 'a'}, store.ref('input'))
-			node('input', {type: 'checkbox', checked: true}, store.ref('checkbox'))
-			node('input', {type: 'radio', name: 'abc', value: 'x', checked: false}, store.ref('radio'))
-			node('input', {type: 'radio', name: 'abc', value: 'y', checked: true}, store.ref('radio'))
-			node('input', {type: 'radio', name: 'abc', value: 'z', checked: false}, store.ref('radio'))
-		})
-		assertEqual(store.get(), {input: 'a', checkbox: true, radio: 'y'})
-	})
-
-	it('changes DOM when Store value is updated', () => {
-		let store = new Store("test")
-		let toggle = new Store(true)
-		mount(document.body, () => {
-			node('input', store)
-			node('input', {type: 'checkbox'}, toggle)
-		})
-		assertBody(`input{value="test"} input{@type="checkbox" checked=true}`)
-
-		store.set("changed")
-		toggle.set(false)
-		passTime()
-		assertBody(`input{value="changed"} input{@type="checkbox" checked=false}`)
-	})
-
-	it('returns numbers for number/range typed inputs', () => {
-		let store = new Store("")
-		let inputElement;
-		mount(document.body, () => {
-			node('input', {type: 'number'}, store, () => {
-				inputElement = getParentElement()
-			})
-		})
-		assertBody(`input{@type="number" value=""}`)
-
-		inputElement.value = "123"
-		inputElement.event("input")
-		passTime()
-		assertEqual(store.get(), 123)
-
-		inputElement.value = ""
-		inputElement.event("input")
-		passTime()
-		assertEqual(store.get(), null)
-	})
-})

package/tests/browsers.js

@@ -1,22 +0,0 @@
-describe('Browsers', () => {
-	it('works without Array.from', () => {
-		let oldFrom = Array.from
-		Array.from = undefined
-		
-		let store = new Store(false)
-		let cnt = 0
-		mount(document.body, () => {
-			cnt++
-			if (store.get()) node('a')
-		})
-		assertBody(``)
-
-
-		store.set(true)
-		passTime()
-		assertBody(`a{}`)
-		assertEqual(cnt, 2)
-
-		Array.from = oldFrom
-	})
-})

package/tests/clean.js

@@ -1,26 +0,0 @@
-describe('Clean', function() {
-	it('triggers once when redrawing', () => {
-
-        let cnt1 = 0, cnt2 = 0
-        let store = new Store(1)
-        mount(document.body, () => {
-            cnt1++
-            text(store.get())
-            clean(() => {
-                cnt2++
-            })
-        })
-
-        passTime()
-        assertBody(`"1"`)
-        assertEqual([cnt1, cnt2], [1, 0])
-
-        store.set(2)
-        passTime()
-        assertBody(`"2"`)
-        assertEqual([cnt1, cnt2], [2, 1])
-
-        unmount()
-        assertEqual([cnt1, cnt2], [2, 2])
-    })
-})

package/tests/count.js

@@ -1,105 +0,0 @@
-describe('Count', () => {
-	it('reactively counts object keys', () => {
-        let store = new Store()
-        let cnt = 0
-        mount(document.body, () => {
-            text(store.count())
-            cnt++
-        })
-        passTime()
-        assertBody(`"0"`)
-        assertEqual(cnt, 1)
-
-        store.set('a', 1)
-        passTime()
-        assertBody(`"1"`)
-        assertEqual(cnt, 2)
-
-        store.set('a', 2)
-        passTime()
-        assertBody(`"1"`)
-        assertEqual(cnt, 2)
-
-        store.set('b', 1)
-        passTime()
-        assertBody(`"2"`)
-        assertEqual(cnt, 3)
-
-        store.delete('a')
-        passTime()
-        assertBody(`"1"`)
-        assertEqual(cnt, 4)
-
-        store.delete('b')
-        passTime()
-        assertBody(`"0"`)
-        assertEqual(cnt, 5)
-    })
-
-    it('counts non-reflectively', () => {
-        let cases = [
-            {data: [], count: 0},
-            {data: [1,2], count: 2},
-            {data: {}, count: 0},
-            {data: {a:1, b:2}, count: 2},
-            {data: objToMap({}), count: 0},
-            {data: objToMap({a:1, b:2}), count: 2},
-        ]
-        for(let c of cases) {
-            let store = new Store(c.data)
-            assertEqual(store.count(), c.count)
-            assertEqual(store.isEmpty(), c.count==0)
-        }
-    })
-
-    it('throws when counting uncountable things', () => {
-        let store = new Store({a: 3})
-        assertThrow(() => {
-            store.count('a')
-        })
-        assertThrow(() => {
-            store.isEmpty('a')
-        })
-        assertEqual(store.count('b'), 0)
-        assertEqual(store.count('b', 'c', 'd'), 0)
-        assertEqual(store.isEmpty('b'), true)
-        assertEqual(store.isEmpty('b', 'c', 'd'), true)
-    })
-
-    it('reactively handles isEmpty', () => {
-        let store = new Store()
-        let cnt = 0
-        mount(document.body, () => {
-            text(store.isEmpty())
-            cnt++
-        })
-        passTime()
-        assertBody(`"true"`)
-        assertEqual(cnt, 1)
-
-        store.set('a', 1)
-        passTime()
-        assertBody(`"false"`)
-        assertEqual(cnt, 2)
-
-        store.set('a', 2)
-        passTime()
-        assertBody(`"false"`)
-        assertEqual(cnt, 2)
-
-        store.set('b', 1)
-        passTime()
-        assertBody(`"false"`)
-        assertEqual(cnt, 2)
-
-        store.delete('a')
-        passTime()
-        assertBody(`"false"`)
-        assertEqual(cnt, 2)
-
-        store.delete('b')
-        passTime()
-        assertBody(`"true"`)
-        assertEqual(cnt, 3)
-    })
-})