Increase code coverage

src/generators/dom/visitors/Element/meta/Window.ts

@@ -83,10 +83,6 @@ export default function visitWindow(
 
 			const associatedEvent = associatedEvents[attribute.name];
 
-			if (!associatedEvent) {
-				throw new Error(`Cannot bind to ${attribute.name} on <:Window>`);
-			}
-
 			if (!events[associatedEvent]) events[associatedEvent] = [];
 			events[associatedEvent].push(
 				`${attribute.value.name}: this.${attribute.name}`

src/generators/shared/utils/isChildOfComponent.ts

@@ -7,7 +7,4 @@ export default function isChildOfComponent(node: Node, generator: Generator) {
 		if (generator.components.has(node.name)) return true;
 		if (/-/.test(node.name)) return false;
 	}
-
-	// TODO do this in validation
-	throw new Error(`Element with a slot='...' attribute must be a descendant of a component or custom element`);
 }

src/generators/shared/utils/wrapModule.ts

@@ -1,4 +1,5 @@
 import deindent from '../../../utils/deindent';
+import list from '../../../utils/list';
 import { CompileOptions, ModuleFormat, Node } from '../../../interfaces';
 
 interface Dependency {
@@ -65,7 +66,7 @@ export default function wrapModule(
 	if (format === 'umd') return umd(code, name, options, banner, dependencies);
 	if (format === 'eval') return expr(code, name, options, banner, dependencies);
 
-	throw new Error(`Not implemented: ${format}`);
+	throw new Error(`options.format is invalid (must be ${list(Object.keys(wrappers))})`);
 }
 
 function es(

src/validate/html/validateElement.ts

@@ -1,6 +1,6 @@
 import * as namespaces from '../../utils/namespaces';
 import validateEventHandler from './validateEventHandler';
-import { Validator } from '../index';
+import validate, { Validator } from '../index';
 import { Node } from '../../interfaces';
 
 const svg = /^(?:altGlyph|altGlyphDef|altGlyphItem|animate|animateColor|animateMotion|animateTransform|circle|clipPath|color-profile|cursor|defs|desc|discard|ellipse|feBlend|feColorMatrix|feComponentTransfer|feComposite|feConvolveMatrix|feDiffuseLighting|feDisplacementMap|feDistantLight|feDropShadow|feFlood|feFuncA|feFuncB|feFuncG|feFuncR|feGaussianBlur|feImage|feMerge|feMergeNode|feMorphology|feOffset|fePointLight|feSpecularLighting|feSpotLight|feTile|feTurbulence|filter|font|font-face|font-face-format|font-face-name|font-face-src|font-face-uri|foreignObject|g|glyph|glyphRef|hatch|hatchpath|hkern|image|line|linearGradient|marker|mask|mesh|meshgradient|meshpatch|meshrow|metadata|missing-glyph|mpath|path|pattern|polygon|polyline|radialGradient|rect|set|solidcolor|stop|switch|symbol|text|textPath|title|tref|tspan|unknown|use|view|vkern)$/;
@@ -191,22 +191,7 @@ export default function validateElement(
 			}
 
 			if (attribute.name === 'slot' && !isComponent) {
-				let i = stack.length;
+				checkSlotAttribute(validator, node, attribute, stack);
-				while (i--) {
-					const parent = stack[i];
-					if (parent.type === 'Element' && validator.components.has(parent.name)) break;
-					if (parent.type === 'IfBlock' || parent.type === 'EachBlock') {
-						const message = `Cannot place slotted elements inside an ${parent.type === 'IfBlock' ? 'if' : 'each'}-block`;
-						validator.error(message, attribute.start);
-					}
-				}
-
-				if (isDynamic(attribute)) {
-					validator.error(
-						`slot attribute cannot have a dynamic value`,
-						attribute.start
-					);
-				}
 			}
 		}
 	});
@@ -232,6 +217,32 @@ function checkTypeAttribute(validator: Validator, node: Node) {
 	return attribute.value[0].data;
 }
 
+function checkSlotAttribute(validator: Validator, node: Node, attribute: Node, stack: Node[]) {
+	if (isDynamic(attribute)) {
+		validator.error(
+			`slot attribute cannot have a dynamic value`,
+			attribute.start
+		);
+	}
+
+	let i = stack.length;
+	while (i--) {
+		const parent = stack[i];
+		if (parent.type === 'Element') {
+			// if we're inside a component or a custom element, gravy
+			if (validator.components.has(parent.name)) return;
+			if (/-/.test(parent.name)) return;
+		}
+
+		if (parent.type === 'IfBlock' || parent.type === 'EachBlock') {
+			const message = `Cannot place slotted elements inside an ${parent.type === 'IfBlock' ? 'if' : 'each'}-block`;
+			validator.error(message, attribute.start);
+		}
+	}
+
+	validator.error(`Element with a slot='...' attribute must be a descendant of a component or custom element`, attribute.start);
+}
+
 function isDynamic(attribute: Node) {
 	return attribute.value.length > 1 || attribute.value[0].type !== 'Text';
 }

src/validate/html/validateEventHandler.ts

@@ -1,5 +1,5 @@
 import flattenReference from '../../utils/flattenReference';
-import list from '../utils/list';
+import list from '../../utils/list';
 import { Validator } from '../index';
 import validCalleeObjects from '../../utils/validCalleeObjects';
 import { Node } from '../../interfaces';

src/validate/html/validateWindow.ts

@@ -1,6 +1,6 @@
 import flattenReference from '../../utils/flattenReference';
 import fuzzymatch from '../utils/fuzzymatch';
-import list from '../utils/list';
+import list from '../../utils/list';
 import validateEventHandler from './validateEventHandler';
 import { Validator } from '../index';
 import { Node } from '../../interfaces';

src/validate/js/propValidators/components.ts

@@ -10,7 +10,6 @@ export default function components(validator: Validator, prop: Node) {
 			`The 'components' property must be an object literal`,
 			prop.start
 		);
-		return;
 	}
 
 	checkForDupes(validator, prop.value.properties);

src/validate/js/propValidators/computed.ts

@@ -14,7 +14,6 @@ export default function computed(validator: Validator, prop: Node) {
 			`The 'computed' property must be an object literal`,
 			prop.start
 		);
-		return;
 	}
 
 	checkForDupes(validator, prop.value.properties);
@@ -26,7 +25,6 @@ export default function computed(validator: Validator, prop: Node) {
 				`Computed properties can be function expressions or arrow function expressions`,
 				computation.value.start
 			);
-			return;
 		}
 
 		const params = computation.value.params;
@@ -36,7 +34,6 @@ export default function computed(validator: Validator, prop: Node) {
 				`A computed value must depend on at least one property`,
 				computation.value.start
 			);
-			return;
 		}
 
 		params.forEach((param: Node) => {

src/validate/js/propValidators/events.ts

@@ -9,7 +9,6 @@ export default function events(validator: Validator, prop: Node) {
 			`The 'events' property must be an object literal`,
 			prop.start
 		);
-		return;
 	}
 
 	checkForDupes(validator, prop.value.properties);

src/validate/js/propValidators/helpers.ts

@@ -10,7 +10,6 @@ export default function helpers(validator: Validator, prop: Node) {
 			`The 'helpers' property must be an object literal`,
 			prop.start
 		);
-		return;
 	}
 
 	checkForDupes(validator, prop.value.properties);

src/validate/js/propValidators/methods.ts

@@ -14,7 +14,6 @@ export default function methods(validator: Validator, prop: Node) {
 			`The 'methods' property must be an object literal`,
 			prop.start
 		);
-		return;
 	}
 
 	checkForAccessors(validator, prop.value.properties, 'Methods');

src/validate/js/propValidators/transitions.ts

@@ -9,7 +9,6 @@ export default function transitions(validator: Validator, prop: Node) {
 			`The 'transitions' property must be an object literal`,
 			prop.start
 		);
-		return;
 	}
 
 	checkForDupes(validator, prop.value.properties);

test/formats/index.js

@@ -157,6 +157,51 @@ describe("formats", () => {
 
 			return testIife(code, "Foo", { answer: 42 }, `<div>42</div>`);
 		});
+
+		it('requires options.name', () => {
+			assert.throws(() => {
+				svelte.compile('', {
+					format: 'iife'
+				});
+			}, /Missing required 'name' option for IIFE export/);
+		});
+
+		it('suggests using options.globals for default imports', () => {
+			const warnings = [];
+
+			svelte.compile(`
+				<script>
+					import _ from 'lodash';
+				</script>
+			`,
+				{
+					format: 'iife',
+					name: 'App',
+					onwarn: warning => {
+						warnings.push(warning);
+					}
+				}
+			);
+
+			assert.deepEqual(warnings, [{
+				message: `No name was supplied for imported module 'lodash'. Guessing '_', but you should use options.globals`
+			}]);
+		});
+
+		it('insists on options.globals for named imports', () => {
+			assert.throws(() => {
+				svelte.compile(`
+					<script>
+						import { fade } from 'svelte-transitions';
+					</script>
+				`,
+					{
+						format: 'iife',
+						name: 'App'
+					}
+				);
+			}, /Could not determine name for imported module 'svelte-transitions' – use options.globals/);
+		});
 	});
 
 	describe("umd", () => {
@@ -190,6 +235,14 @@ describe("formats", () => {
 			testCjs(code, { answer: 42 }, `<div>42</div>`);
 			testIife(code, "Foo", { answer: 42 }, `<div>42</div>`);
 		});
+
+		it('requires options.name', () => {
+			assert.throws(() => {
+				svelte.compile('', {
+					format: 'umd'
+				});
+			}, /Missing required 'name' option for UMD export/);
+		});
 	});
 
 	describe("eval", () => {
@@ -218,4 +271,14 @@ describe("formats", () => {
 			return testEval(code, "Foo", { answer: 42 }, `<div>42</div>`);
 		});
 	});
+
+	describe('unknown format', () => {
+		it('throws an error', () => {
+			assert.throws(() => {
+				svelte.compile('', {
+					format: 'nope'
+				});
+			}, /options.format is invalid \(must be es, amd, cjs, iife, umd or eval\)/);
+		});
+	});
 });

test/js/samples/window-binding-scroll/expected-bundle.js

@@ -0,0 +1,256 @@
+function noop() {}
+
+function assign(target) {
+	var k,
+		source,
+		i = 1,
+		len = arguments.length;
+	for (; i < len; i++) {
+		source = arguments[i];
+		for (k in source) target[k] = source[k];
+	}
+
+	return target;
+}
+
+function appendNode(node, target) {
+	target.appendChild(node);
+}
+
+function insertNode(node, target, anchor) {
+	target.insertBefore(node, anchor);
+}
+
+function detachNode(node) {
+	node.parentNode.removeChild(node);
+}
+
+function createElement(name) {
+	return document.createElement(name);
+}
+
+function createText(data) {
+	return document.createTextNode(data);
+}
+
+function blankObject() {
+	return Object.create(null);
+}
+
+function destroy(detach) {
+	this.destroy = noop;
+	this.fire('destroy');
+	this.set = this.get = noop;
+
+	if (detach !== false) this._fragment.u();
+	this._fragment.d();
+	this._fragment = this._state = null;
+}
+
+function differs(a, b) {
+	return a !== b || ((a && typeof a === 'object') || typeof a === 'function');
+}
+
+function dispatchObservers(component, group, changed, newState, oldState) {
+	for (var key in group) {
+		if (!changed[key]) continue;
+
+		var newValue = newState[key];
+		var oldValue = oldState[key];
+
+		var callbacks = group[key];
+		if (!callbacks) continue;
+
+		for (var i = 0; i < callbacks.length; i += 1) {
+			var callback = callbacks[i];
+			if (callback.__calling) continue;
+
+			callback.__calling = true;
+			callback.call(component, newValue, oldValue);
+			callback.__calling = false;
+		}
+	}
+}
+
+function fire(eventName, data) {
+	var handlers =
+		eventName in this._handlers && this._handlers[eventName].slice();
+	if (!handlers) return;
+
+	for (var i = 0; i < handlers.length; i += 1) {
+		handlers[i].call(this, data);
+	}
+}
+
+function get(key) {
+	return key ? this._state[key] : this._state;
+}
+
+function init(component, options) {
+	component.options = options;
+
+	component._observers = { pre: blankObject(), post: blankObject() };
+	component._handlers = blankObject();
+	component._root = options._root || component;
+	component._bind = options._bind;
+}
+
+function observe(key, callback, options) {
+	var group = options && options.defer
+		? this._observers.post
+		: this._observers.pre;
+
+	(group[key] || (group[key] = [])).push(callback);
+
+	if (!options || options.init !== false) {
+		callback.__calling = true;
+		callback.call(this, this._state[key]);
+		callback.__calling = false;
+	}
+
+	return {
+		cancel: function() {
+			var index = group[key].indexOf(callback);
+			if (~index) group[key].splice(index, 1);
+		}
+	};
+}
+
+function on(eventName, handler) {
+	if (eventName === 'teardown') return this.on('destroy', handler);
+
+	var handlers = this._handlers[eventName] || (this._handlers[eventName] = []);
+	handlers.push(handler);
+
+	return {
+		cancel: function() {
+			var index = handlers.indexOf(handler);
+			if (~index) handlers.splice(index, 1);
+		}
+	};
+}
+
+function set(newState) {
+	this._set(assign({}, newState));
+	if (this._root._lock) return;
+	this._root._lock = true;
+	callAll(this._root._beforecreate);
+	callAll(this._root._oncreate);
+	callAll(this._root._aftercreate);
+	this._root._lock = false;
+}
+
+function _set(newState) {
+	var oldState = this._state,
+		changed = {},
+		dirty = false;
+
+	for (var key in newState) {
+		if (differs(newState[key], oldState[key])) changed[key] = dirty = true;
+	}
+	if (!dirty) return;
+
+	this._state = assign({}, oldState, newState);
+	this._recompute(changed, this._state);
+	if (this._bind) this._bind(changed, this._state);
+
+	if (this._fragment) {
+		dispatchObservers(this, this._observers.pre, changed, this._state, oldState);
+		this._fragment.p(changed, this._state);
+		dispatchObservers(this, this._observers.post, changed, this._state, oldState);
+	}
+}
+
+function callAll(fns) {
+	while (fns && fns.length) fns.pop()();
+}
+
+function _mount(target, anchor) {
+	this._fragment.m(target, anchor);
+}
+
+function _unmount() {
+	this._fragment.u();
+}
+
+var proto = {
+	destroy: destroy,
+	get: get,
+	fire: fire,
+	observe: observe,
+	on: on,
+	set: set,
+	teardown: destroy,
+	_recompute: noop,
+	_set: _set,
+	_mount: _mount,
+	_unmount: _unmount
+};
+
+/* generated by Svelte vX.Y.Z */
+function create_main_fragment(state, component) {
+	var window_updating = false, text, p, text_1, text_2;
+
+	function onwindowscroll(event) {
+		window_updating = true;
+
+		component.set({
+			y: this.scrollY
+		});
+		window_updating = false;
+	}
+	window.addEventListener("scroll", onwindowscroll);
+
+	component.observe("y", function(y) {
+		if (window_updating) return;
+		window.scrollTo(window.scrollX, y);
+	});
+
+	return {
+		c: function create() {
+			text = createText("\n\n");
+			p = createElement("p");
+			text_1 = createText("scrolled to ");
+			text_2 = createText(state.y);
+		},
+
+		m: function mount(target, anchor) {
+			insertNode(text, target, anchor);
+			insertNode(p, target, anchor);
+			appendNode(text_1, p);
+			appendNode(text_2, p);
+		},
+
+		p: function update(changed, state) {
+			if (changed.y) {
+				text_2.data = state.y;
+			}
+		},
+
+		u: function unmount() {
+			detachNode(text);
+			detachNode(p);
+		},
+
+		d: function destroy$$1() {
+			window.removeEventListener("scroll", onwindowscroll);
+		}
+	};
+}
+
+function SvelteComponent(options) {
+	init(this, options);
+	this._state = assign({}, options.data);
+	this._state.y = window.scrollY;
+
+	this._fragment = create_main_fragment(this._state, this);
+
+	if (options.target) {
+		this._fragment.c();
+		this._fragment.m(options.target, options.anchor || null);
+	}
+}
+
+assign(SvelteComponent.prototype, proto);
+
+export default SvelteComponent;

test/js/samples/window-binding-scroll/expected.js

@@ -0,0 +1,68 @@
+/* generated by Svelte vX.Y.Z */
+import { appendNode, assign, createElement, createText, detachNode, init, insertNode, proto } from "svelte/shared.js";
+
+function create_main_fragment(state, component) {
+	var window_updating = false, text, p, text_1, text_2;
+
+	function onwindowscroll(event) {
+		window_updating = true;
+
+		component.set({
+			y: this.scrollY
+		});
+		window_updating = false;
+	};
+	window.addEventListener("scroll", onwindowscroll);
+
+	component.observe("y", function(y) {
+		if (window_updating) return;
+		window.scrollTo(window.scrollX, y);
+	});
+
+	return {
+		c: function create() {
+			text = createText("\n\n");
+			p = createElement("p");
+			text_1 = createText("scrolled to ");
+			text_2 = createText(state.y);
+		},
+
+		m: function mount(target, anchor) {
+			insertNode(text, target, anchor);
+			insertNode(p, target, anchor);
+			appendNode(text_1, p);
+			appendNode(text_2, p);
+		},
+
+		p: function update(changed, state) {
+			if (changed.y) {
+				text_2.data = state.y;
+			}
+		},
+
+		u: function unmount() {
+			detachNode(text);
+			detachNode(p);
+		},
+
+		d: function destroy() {
+			window.removeEventListener("scroll", onwindowscroll);
+		}
+	};
+}
+
+function SvelteComponent(options) {
+	init(this, options);
+	this._state = assign({}, options.data);
+	this._state.y = window.scrollY;
+
+	this._fragment = create_main_fragment(this._state, this);
+
+	if (options.target) {
+		this._fragment.c();
+		this._fragment.m(options.target, options.anchor || null);
+	}
+}
+
+assign(SvelteComponent.prototype, proto);
+export default SvelteComponent;

test/js/samples/window-binding-scroll/input.html

@@ -0,0 +1,3 @@
+<:Window bind:scrollY=y/>
+
+<p>scrolled to {{y}}</p>

test/validator/samples/binding-input-type-boolean/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "'type' attribute must be specified",
+	"loc": {
+		"line": 1,
+		"column": 24
+	},
+	"pos": 24
+}]

test/validator/samples/binding-input-type-boolean/input.html

@@ -0,0 +1 @@
+<input bind:value='foo' type>

test/validator/samples/namespace-invalid-unguessable/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "Invalid namespace 'lol'",
+	"pos": 29,
+	"loc": {
+		"line": 3,
+		"column": 2
+	}
+}]

test/validator/samples/namespace-invalid-unguessable/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		namespace: 'lol'
+	};
+</script>

test/validator/samples/namespace-non-literal/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "The 'namespace' property must be a string literal representing a valid namespace",
+	"pos": 79,
+	"loc": {
+		"line": 5,
+		"column": 2
+	}
+}]

test/validator/samples/namespace-non-literal/input.html

@@ -0,0 +1,7 @@
+<script>
+	const namespace = 'http://www.w3.org/1999/svg';
+
+	export default {
+		namespace
+	};
+</script>

test/validator/samples/non-object-literal-components/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "The 'components' property must be an object literal",
+	"loc": {
+		"line": 3,
+		"column": 2
+	},
+	"pos": 29
+}]

test/validator/samples/non-object-literal-components/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		components: 'not an object literal'
+	};
+</script>

test/validator/samples/non-object-literal-events/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "The 'events' property must be an object literal",
+	"loc": {
+		"line": 3,
+		"column": 2
+	},
+	"pos": 29
+}]

test/validator/samples/non-object-literal-events/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		events: 'not an object literal'
+	};
+</script>

test/validator/samples/non-object-literal-helpers/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "The 'helpers' property must be an object literal",
+	"loc": {
+		"line": 3,
+		"column": 2
+	},
+	"pos": 29
+}]

test/validator/samples/non-object-literal-helpers/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		helpers: 'not an object literal'
+	};
+</script>

test/validator/samples/non-object-literal-methods/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "The 'methods' property must be an object literal",
+	"loc": {
+		"line": 3,
+		"column": 2
+	},
+	"pos": 29
+}]

test/validator/samples/non-object-literal-methods/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		methods: 'not an object literal'
+	};
+</script>

test/validator/samples/non-object-literal-transitions/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "The 'transitions' property must be an object literal",
+	"loc": {
+		"line": 3,
+		"column": 2
+	},
+	"pos": 29
+}]

test/validator/samples/non-object-literal-transitions/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		transitions: 'not an object literal'
+	};
+</script>

test/validator/samples/slot-attribute-invalid/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "Element with a slot='...' attribute must be a descendant of a component or custom element",
+	"loc": {
+		"line": 1,
+		"column": 5
+	},
+	"pos": 5
+}]

test/validator/samples/slot-attribute-invalid/input.html

@@ -0,0 +1 @@
+<div slot='foo'>invalid</div>

test/validator/samples/tag-invalid/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "tag name must be two or more words joined by the '-' character",
+	"loc": {
+		"line": 3,
+		"column": 7
+	},
+	"pos": 34
+}]

test/validator/samples/tag-invalid/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		tag: 'invalid'
+	};
+</script>

test/validator/samples/tag-non-string/errors.json

@@ -0,0 +1,8 @@
+[{
+	"message": "'tag' must be a string literal",
+	"loc": {
+		"line": 3,
+		"column": 7
+	},
+	"pos": 34
+}]

test/validator/samples/tag-non-string/input.html

@@ -0,0 +1,5 @@
+<script>
+	export default {
+		tag: 42
+	};
+</script>