index.js

const assert = require('assert');
const { promises } = require('fs');
const { resolve } = require('path');
const process = require('process');
const { copy, pathExists, remove } = require('fs-extra');
const rollup = require('../../dist/rollup');

const cwd = process.cwd();

function wait(ms) {
	return new Promise(fulfil => {
		setTimeout(fulfil, ms);
	});
}

describe('rollup.watch', () => {
	let watcher;

	beforeEach(async () => {
		process.chdir(cwd);
		await remove('test/_tmp');
	});

	afterEach(() => {
		if (watcher) {
			watcher.close();
			watcher = null;
		}
	});

	function run(file) {
		const resolved = require.resolve(file);
		delete require.cache[resolved];
		return require(resolved);
	}

	async function sequence(watcher, events, timeout = 300) {
		await new Promise((fulfil, reject) => {
			function go(event) {
				const next = events.shift();

				if (!next) {
					watcher.close();
					fulfil();
				} else if (typeof next === 'string') {
					watcher.once('event', event_1 => {
						if (event_1.code !== next) {
							watcher.close();
							if (event_1.code === 'ERROR') console.log(event_1.error);
							reject(new Error(`Expected ${next} event, got ${event_1.code}`));
						} else {
							go(event_1);
						}
					});
				} else {
					wait(timeout) // gah, this appears to be necessary to fix random errors
						.then(() => next(event))
						.then(go)
						.catch(error => {
							watcher.close();
							reject(error);
						});
				}
			}

			go();
		});
		await wait(100);
	}

	function getTimeDiffInMs(previous) {
		const [seconds, nanoseconds] = process.hrtime(previous);
		return seconds * 1e3 + nanoseconds / 1e6;
	}

	it('watches a file and triggers reruns if necessary', async () => {
		let triggerRestart = false;

		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			plugins: {
				options() {
					assert.strictEqual(this.meta.watchMode, true, 'watchMode in options');
				},
				async transform(code) {
					assert.strictEqual(this.meta.watchMode, true, 'watchMode in transform');
					if (triggerRestart) {
						triggerRestart = false;
						await wait(100);
						await promises.writeFile('test/_tmp/input/main.js', 'export default 44;');
						await wait(100);
						return code;
					}
				}
			},
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				triggerRestart = true;
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 44);
			}
		]);
	});

	it('does not fail for virtual files', async () => {
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			plugins: {
				resolveId(id) {
					if (id === 'virtual') {
						return id;
					}
				},
				load(id_1) {
					if (id_1 === 'virtual') {
						return `export const value = 42;`;
					}
				}
			},
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.writeFile(
					'test/_tmp/input/main.js',
					"import {value} from 'virtual';\nexport default value + 1;"
				);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
			}
		]);
	});

	it('passes file events to the watchChange plugin hook once for each change', async () => {
		let watchChangeCnt = 0;
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		await wait(100);
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			},
			plugins: {
				watchChange(id) {
					watchChangeCnt++;
					assert.strictEqual(id, resolve('test/_tmp/input/main.js'));
				}
			}
		});

		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				watchChangeCnt = 0;
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
				assert.strictEqual(watchChangeCnt, 1);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
				assert.strictEqual(watchChangeCnt, 2);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
				assert.strictEqual(watchChangeCnt, 3);
			}
		]);
	});

	it('passes change parameter to the watchChange plugin hook', async () => {
		const WATCHED_ID = resolve('test/_tmp/input/watched');
		const events = [];
		let ids;
		const expectedIds = [WATCHED_ID, resolve('test/_tmp/input/main.js')];
		await copy('test/watch/samples/watch-files', 'test/_tmp/input');
		await promises.unlink(WATCHED_ID);
		await wait(100);
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			},
			plugins: {
				buildStart() {
					this.addWatchFile(WATCHED_ID);
				},
				watchChange(id, { event }) {
					assert.strictEqual(id, WATCHED_ID);
					events.push(event);
				},
				buildEnd() {
					ids = this.getWatchFiles();
				}
			}
		});

		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				assert.deepStrictEqual(events, []);
				assert.deepStrictEqual(ids, expectedIds);
				await promises.writeFile(WATCHED_ID, 'first');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				assert.deepStrictEqual(events, ['create']);
				assert.deepStrictEqual(ids, expectedIds);
				await promises.writeFile(WATCHED_ID, 'first');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				assert.deepStrictEqual(events, ['create', 'update']);
				assert.deepStrictEqual(ids, expectedIds);
				await promises.unlink(WATCHED_ID);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				assert.deepStrictEqual(events, ['create', 'update', 'delete']);
				assert.deepStrictEqual(ids, expectedIds);
			}
		]);
	});

	it('correctly rewrites change event during build delay', async () => {
		const WATCHED_ID = resolve('test/_tmp/input/watched');
		const MAIN_ID = resolve('test/_tmp/input/main.js');
		let lastEvent = null;
		await copy('test/watch/samples/watch-files', 'test/_tmp/input');
		await wait(100);
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			},
			watch: {
				buildDelay: 300,
				chokidar: {
					atomic: false
				}
			},
			plugins: {
				buildStart() {
					this.addWatchFile(WATCHED_ID);
				},
				watchChange(id, { event }) {
					if (id === WATCHED_ID) {
						assert.strictEqual(lastEvent, null);
						lastEvent = event;
					}
				}
			}
		});

		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(lastEvent, null);
				await promises.writeFile(WATCHED_ID, 'another');
				await wait(100);
				await promises.unlink(WATCHED_ID);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(lastEvent, 'delete');
				lastEvent = null;
				await promises.writeFile(WATCHED_ID, '123');
				await wait(100);
				await promises.unlink(WATCHED_ID);
				// To ensure there is always another change to trigger a rebuild
				await promises.writeFile(MAIN_ID, 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(lastEvent, null);
				await promises.writeFile(WATCHED_ID, '123');
				await wait(100);
				await promises.writeFile(WATCHED_ID, 'asd');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(lastEvent, 'create');
			}
		]);
	}).timeout(20000);

	it('calls closeWatcher plugin hook', async () => {
		let calls = 0;
		let ctx1;
		let ctx2;
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			},
			plugins: [
				{
					buildStart() {
						ctx1 = this;
					},
					closeWatcher() {
						assert.strictEqual(ctx1, this);
						calls++;
					}
				},
				{
					buildStart() {
						ctx2 = this;
					},
					closeWatcher() {
						assert.strictEqual(ctx2, this);
						calls++;
					}
				}
			]
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				assert.ok(ctx1);
				assert.ok(ctx2);
				watcher.once('close', () => {
					assert.strictEqual(calls, 2);
				});
				watcher.close();
			}
		]);
	});

	it('watches a file in code-splitting mode', async () => {
		await copy('test/watch/samples/code-splitting', 'test/_tmp/input');
		watcher = rollup.watch({
			input: ['test/_tmp/input/main1.js', 'test/_tmp/input/main2.js'],
			output: {
				dir: 'test/_tmp/output',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/main1.js'), 21);
				assert.strictEqual(run('../_tmp/output/main2.js'), 42);
				await promises.writeFile('test/_tmp/input/shared.js', 'export const value = 22;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/main1.js'), 22);
				assert.strictEqual(run('../_tmp/output/main2.js'), 44);
			}
		]);
	});

	it('watches a file in code-splitting mode with an input object', async () => {
		await copy('test/watch/samples/code-splitting', 'test/_tmp/input');
		watcher = rollup.watch({
			input: {
				_main_1: 'test/_tmp/input/main1.js',
				'subfolder/_main_2': 'test/_tmp/input/main2.js'
			},
			output: {
				dir: 'test/_tmp/output',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/_main_1.js'), 21);
				assert.strictEqual(run('../_tmp/output/subfolder/_main_2.js'), 42);
				await promises.writeFile('test/_tmp/input/shared.js', 'export const value = 22;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/_main_1.js'), 22);
				assert.strictEqual(run('../_tmp/output/subfolder/_main_2.js'), 44);
			}
		]);
	});

	it('recovers from an error', async () => {
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.writeFile('test/_tmp/input/main.js', 'export nope;');
			},
			'START',
			'BUNDLE_START',
			'ERROR',
			async () => {
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
			}
		]);
	});

	it('recovers from an error on initial build', async () => {
		await copy('test/watch/samples/error', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'ERROR',
			async () => {
				assert.strictEqual(await pathExists('../_tmp/output/bundle.js'), false);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
			}
		]);
	});

	it('recovers from a plugin error on initial build', async () => {
		let count = 0;
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			plugins: {
				transform() {
					if (count++ === 0) {
						this.error('The first run failed, try again.');
					}
				}
			},
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'ERROR',
			async () => {
				assert.strictEqual(await pathExists('../_tmp/output/bundle.js'), false);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
			}
		]);
	});

	it('recovers from an error even when erroring entry was "renamed" (#38)', async () => {
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.unlink('test/_tmp/input/main.js');
				await promises.writeFile('test/_tmp/input/main.js', 'export nope;');
			},
			'START',
			'BUNDLE_START',
			'ERROR',
			async () => {
				await promises.unlink('test/_tmp/input/main.js');
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
			}
		]);
	});

	it('recovers from an error even when erroring dependency was "renamed" (#38)', async () => {
		await copy('test/watch/samples/dependency', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
				await promises.unlink('test/_tmp/input/dep.js');
				await promises.writeFile('test/_tmp/input/dep.js', 'export nope;');
			},
			'START',
			'BUNDLE_START',
			'ERROR',
			async () => {
				await promises.unlink('test/_tmp/input/dep.js');
				await promises.writeFile('test/_tmp/input/dep.js', 'export const value = 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 44);
			}
		]);
	});

	it('handles closing the watcher during a build', async () => {
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			plugins: {
				load() {
					watcher.close();
				}
			},
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		const events = [];
		watcher.on('event', event_1 => events.push(event_1.code));
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			async () => {
				await promises.writeFile('test/_tmp/input/main.js', 'export default 44;');
				await wait(400);
				assert.deepStrictEqual(events, ['START', 'BUNDLE_START']);
			}
		]);
	});

	it('handles closing the watcher during a build even if an error occurred', async () => {
		await copy('test/watch/samples/error', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			plugins: {
				load() {
					watcher.close();
				}
			},
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		const events = [];
		watcher.on('event', event_1 => events.push(event_1.code));
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			async () => {
				await promises.writeFile('test/_tmp/input/main.js', 'export default 44;');
				await wait(400);
				assert.deepStrictEqual(events, ['START', 'BUNDLE_START']);
			}
		]);
	});

	it('stops watching files that are no longer part of the graph', async () => {
		await copy('test/watch/samples/dependency', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 42;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				let unexpectedEvent = false;
				watcher.once('event', event => {
					unexpectedEvent = event;
				});
				await promises.writeFile('test/_tmp/input/dep.js', '= invalid');
				await wait(400);
				assert.strictEqual(unexpectedEvent, false);
			}
		]);
	});

	it('refuses to watch the output file (#15)', async () => {
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.writeFile('test/_tmp/input/main.js', `import '../output/bundle.js'`);
			},
			'START',
			'BUNDLE_START',
			'ERROR',
			async event => {
				assert.strictEqual(event.error.message, 'Cannot import the generated bundle');
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
			}
		]);
	});

	it('ignores files that are not specified in options.watch.include, if given', async () => {
		await copy('test/watch/samples/ignored', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			},
			watch: {
				include: ['test/_tmp/input/+(main|foo).js']
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.deepStrictEqual(run('../_tmp/output/bundle.js'), {
					foo: 'foo-1',
					bar: 'bar-1'
				});
				await promises.writeFile('test/_tmp/input/foo.js', `export default 'foo-2';`);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.deepStrictEqual(run('../_tmp/output/bundle.js'), {
					foo: 'foo-2',
					bar: 'bar-1'
				});
				let unexpectedEvent = false;
				watcher.once('event', event => {
					unexpectedEvent = event;
				});
				await promises.writeFile('test/_tmp/input/bar.js', "export default 'bar-2';");
				await wait(400);
				assert.deepStrictEqual(run('../_tmp/output/bundle.js'), {
					foo: 'foo-2',
					bar: 'bar-1'
				});
				assert.strictEqual(unexpectedEvent, false);
			}
		]);
	});

	it('ignores files that are specified in options.watch.exclude, if given', async () => {
		await copy('test/watch/samples/ignored', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			},
			watch: {
				exclude: ['test/_tmp/input/bar.js']
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.deepStrictEqual(run('../_tmp/output/bundle.js'), {
					foo: 'foo-1',
					bar: 'bar-1'
				});
				await promises.writeFile('test/_tmp/input/foo.js', `export default 'foo-2';`);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.deepStrictEqual(run('../_tmp/output/bundle.js'), {
					foo: 'foo-2',
					bar: 'bar-1'
				});
				let unexpectedEvent = false;
				watcher.once('event', event => {
					unexpectedEvent = event;
				});
				await promises.writeFile('test/_tmp/input/bar.js', "export default 'bar-2';");
				await wait(400);
				assert.deepStrictEqual(run('../_tmp/output/bundle.js'), {
					foo: 'foo-2',
					bar: 'bar-1'
				});
				assert.strictEqual(unexpectedEvent, false);
			}
		]);
	});

	it('only rebuilds the appropriate configs', async () => {
		await copy('test/watch/samples/multiple', 'test/_tmp/input');
		await wait(100);
		watcher = rollup.watch([
			{
				input: 'test/_tmp/input/main1.js',
				output: {
					file: 'test/_tmp/output/bundle1.js',
					format: 'cjs',
					exports: 'auto'
				}
			},
			{
				input: 'test/_tmp/input/main2.js',
				output: {
					file: 'test/_tmp/output/bundle2.js',
					format: 'cjs',
					exports: 'auto'
				}
			}
		]);
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.deepStrictEqual(run('../_tmp/output/bundle1.js'), 42);
				assert.deepStrictEqual(run('../_tmp/output/bundle2.js'), 43);
				await promises.writeFile('test/_tmp/input/main2.js', 'export default 44');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.deepStrictEqual(run('../_tmp/output/bundle1.js'), 42);
				assert.deepStrictEqual(run('../_tmp/output/bundle2.js'), 44);
			}
		]);
	});

	it('allows watching only some configs', async () => {
		await copy('test/watch/samples/multiple', 'test/_tmp/input');
		await wait(100);
		watcher = rollup.watch([
			{
				input: 'test/_tmp/input/main1.js',
				watch: false,
				output: {
					file: 'test/_tmp/output/bundle1.js',
					format: 'cjs',
					exports: 'auto'
				}
			},
			{
				input: 'test/_tmp/input/main2.js',
				output: {
					file: 'test/_tmp/output/bundle2.js',
					format: 'cjs',
					exports: 'auto'
				}
			}
		]);
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(
					await pathExists(resolve(__dirname, '../_tmp/output/bundle1.js')),
					false
				);
				assert.strictEqual(await pathExists(resolve(__dirname, '../_tmp/output/bundle2.js')), true);
				assert.deepStrictEqual(run('../_tmp/output/bundle2.js'), 43);
			}
		]);
	});

	it('respects output.globals', async () => {
		await copy('test/watch/samples/globals', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'iife',
				globals: {
					jquery: 'jQuery'
				}
			},
			external: ['jquery']
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				const generated = await promises.readFile('test/_tmp/output/bundle.js', 'utf8');
				assert.ok(/jQuery/.test(generated));
			}
		]);
	});

	it('treats filenames literally, not as globs', async () => {
		await copy('test/watch/samples/non-glob', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.writeFile('test/_tmp/input/[foo]/bar.js', `export const bar = 43;`);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
			}
		]);
	});

	it('updates the right hashes on dependency changes', async () => {
		let dynamicName;
		let staticName;
		let chunkName;
		await copy('test/watch/samples/hashing', 'test/_tmp/input');
		watcher = rollup.watch({
			input: ['test/_tmp/input/main-static.js', 'test/_tmp/input/main-dynamic.js'],
			output: {
				dir: 'test/_tmp/output',
				format: 'cjs',
				exports: 'auto',
				entryFileNames: '[name].[hash].js',
				chunkFileNames: '[name].[hash].js'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				[dynamicName, staticName, chunkName] = (await promises.readdir('test/_tmp/output')).sort();
				await remove('test/_tmp/output');

				// this should only update the hash of that particular entry point
				await promises.writeFile(
					'test/_tmp/input/main-static.js',
					"import {value} from './shared';\nexport default 2 * value;"
				);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				const [newDynamicName, newStaticName, newChunkName] = (
					await promises.readdir('test/_tmp/output')
				).sort();
				await remove('test/_tmp/output');
				assert.notEqual(newStaticName, staticName);
				assert.strictEqual(newDynamicName, dynamicName);
				assert.strictEqual(newChunkName, chunkName);
				staticName = newStaticName;

				// this should update all hashes
				await promises.writeFile('test/_tmp/input/shared.js', 'export const value = 42;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				const [newDynamicName_1, newStaticName_1, newChunkName_1] = (
					await promises.readdir('test/_tmp/output')
				).sort();
				assert.notEqual(newStaticName_1, staticName);
				assert.notEqual(newDynamicName_1, dynamicName);
				assert.notEqual(newChunkName_1, chunkName);
			}
		]);
	});

	it('runs transforms again on previously erroring files that were changed back', () => {
		const brokenFiles = new Set();
		const INITIAL_CONTENT = 'export default 42;';
		await promises.writeFile('test/_tmp/input/main.js', INITIAL_CONTENT);
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			plugins: {
				transform(code, id) {
					if (code.includes('broken')) {
						brokenFiles.add(id);
						throw new Error('Broken in transform');
					} else {
						brokenFiles.delete(id);
					}
				},
				generateBundle() {
					if (brokenFiles.size > 0) {
						throw new Error('Broken in generate');
					}
				}
			},
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.writeFile('test/_tmp/input/main.js', 'export default "broken";');
			},
			'START',
			'BUNDLE_START',
			'ERROR',
			async () => {
				await promises.writeFile('test/_tmp/input/main.js', INITIAL_CONTENT);
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
			}
		]);
	});

	it('skips filesystem writes when configured', async () => {
		let watchChangeCnt = 0;
		await copy('test/watch/samples/skip-writes', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			},
			watch: {
				skipWrite: true
			},
			plugins: {
				watchChange(id) {
					watchChangeCnt++;
					assert.strictEqual(id, resolve('test/_tmp/input/main.js'));
				}
			}
		});
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				watchChangeCnt = 0;
				assert.strictEqual(await pathExists('../_tmp/output/bundle.js'), false);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(await pathExists('../_tmp/output/bundle.js'), false);
				assert.strictEqual(watchChangeCnt, 1);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(await pathExists('../_tmp/output/bundle.js'), false);
				assert.strictEqual(watchChangeCnt, 2);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			// 'END',
			async evt => {
				assert.strictEqual(await pathExists('../_tmp/output/bundle.js'), false);
				assert.strictEqual(watchChangeCnt, 3);
				// still aware of its output destination
				assert.strictEqual(evt.output[0], resolve('test/_tmp/output/bundle.js'));
			}
		]);
	});

	it('rebuilds immediately by default', async () => {
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch({
			input: 'test/_tmp/input/main.js',
			output: {
				file: 'test/_tmp/output/bundle.js',
				format: 'cjs',
				exports: 'auto'
			}
		});

		let startTime;
		return sequence(
			watcher,
			[
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
					await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
					startTime = process.hrtime();
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
					const timeDiff = getTimeDiffInMs(startTime);
					assert.ok(timeDiff < 400, `Time difference ${timeDiff} < 400`);
				}
			],
			0
		);
	});

	it('observes configured build delays', async () => {
		await copy('test/watch/samples/basic', 'test/_tmp/input');
		watcher = rollup.watch(
			[
				{
					input: 'test/_tmp/input/main.js',
					output: {
						file: 'test/_tmp/output/bundle.js',
						format: 'cjs',
						exports: 'auto'
					}
				},
				{
					input: 'test/_tmp/input/main.js',
					watch: { clearScreen: true },
					output: {
						file: 'test/_tmp/output/bundle.js',
						format: 'cjs',
						exports: 'auto'
					}
				},
				{
					input: 'test/_tmp/input/main.js',
					watch: { buildDelay: 1000 },
					output: {
						file: 'test/_tmp/output/bundle.js',
						format: 'cjs',
						exports: 'auto'
					}
				},
				{
					input: 'test/_tmp/input/main.js',
					watch: { buildDelay: 50 },
					output: {
						file: 'test/_tmp/output/bundle.js',
						format: 'cjs',
						exports: 'auto'
					}
				}
			],
			0
		);

		let startTime;
		return sequence(watcher, [
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'BUNDLE_START',
			'BUNDLE_END',
			'BUNDLE_START',
			'BUNDLE_END',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			async () => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
				await promises.writeFile('test/_tmp/input/main.js', 'export default 43;');
				startTime = process.hrtime();
			},
			'START',
			'BUNDLE_START',
			'BUNDLE_END',
			'BUNDLE_START',
			'BUNDLE_END',
			'BUNDLE_START',
			'BUNDLE_END',
			'BUNDLE_START',
			'BUNDLE_END',
			'END',
			() => {
				assert.strictEqual(run('../_tmp/output/bundle.js'), 43);
				const timeDiff = getTimeDiffInMs(startTime);
				assert.ok(timeDiff > 1000, `Time difference ${timeDiff} > 1000`);
			}
		]);
	});

	describe('addWatchFile', () => {
		it('supports adding additional watch files in plugin hooks', async () => {
			const watchChangeIds = new Set();
			const buildStartFile = resolve('test/_tmp/input/buildStart');
			const loadFile = resolve('test/_tmp/input/load');
			const resolveIdFile = resolve('test/_tmp/input/resolveId');
			const transformFile = resolve('test/_tmp/input/transform');
			const watchFiles = [buildStartFile, loadFile, resolveIdFile, transformFile];
			await copy('test/watch/samples/basic', 'test/_tmp/input');

			await Promise.all(watchFiles.map(file => promises.writeFile(file, 'initial')));

			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					buildStart() {
						this.addWatchFile(buildStartFile);
					},
					load() {
						this.addWatchFile(loadFile);
					},
					resolveId() {
						this.addWatchFile(resolveIdFile);
					},
					transform() {
						this.addWatchFile(transformFile);
					},
					watchChange(id) {
						watchChangeIds.add(id);
					}
				}
			});
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
					// sometimes the watcher is triggered during the initial run
					watchChangeIds.clear();
					await Promise.all(watchFiles.map(file_2 => promises.writeFile(file_2, 'changed')));
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 42);
					assert.deepStrictEqual([...watchChangeIds].sort(), watchFiles.sort());
				}
			]);
		});

		it('respects changed watched files in the load hook', async () => {
			const WATCHED_ID = resolve('test/_tmp/input/watched');
			await copy('test/watch/samples/watch-files', 'test/_tmp/input');
			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					async load() {
						this.addWatchFile(WATCHED_ID);
						return `export default "${(await promises.readFile(WATCHED_ID, 'utf8')).trim()}"`;
					}
				}
			});
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 'initial');
					await promises.writeFile(WATCHED_ID, 'next');
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 'next');
				}
			]);
		});

		it('respects changed watched files in the transform hook and removes them if they are no longer watched', async () => {
			const WATCHED_ID = resolve('test/_tmp/input/watched');
			let addWatchFile = true;
			await copy('test/watch/samples/watch-files', 'test/_tmp/input');
			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					resolveId(id) {
						if (id === 'dep') {
							return id;
						}
					},
					load(id_1) {
						if (id_1 === 'dep') {
							return `throw new Error('This should not be executed);`;
						}
					},
					async transform(code, id_2) {
						if (id_2.endsWith('main.js')) {
							return `export { value as default } from 'dep';`;
						} else {
							if (addWatchFile) {
								this.addWatchFile(WATCHED_ID);
							}
							return `export const value = "${(
								await promises.readFile(WATCHED_ID, 'utf8')
							).trim()}"`;
						}
					}
				}
			});
			const events = [];
			watcher.on('event', event_1 => events.push(event_1.code));
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 'initial');
					addWatchFile = false;
					await promises.writeFile(WATCHED_ID, 'next');
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), 'next');
					await promises.writeFile(WATCHED_ID, 'other');
					events.length = 0;
					await wait(400);
					assert.deepStrictEqual(events, []);
				}
			]);
		});

		it('respects changed watched modules that are already part of the graph in the transform hook', async () => {
			await copy('test/watch/samples/dependencies', 'test/_tmp/input');
			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					async transform(code, id) {
						if (id.endsWith('dep1.js')) {
							this.addWatchFile(resolve('test/_tmp/input/dep2.js'));
							const text = (await promises.readFile('test/_tmp/input/dep2.js', 'utf8')).trim();
							return `export default ${JSON.stringify(text)}`;
						}
					}
				}
			});
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(
						run('../_tmp/output/bundle.js'),
						`dep1: "export default 'dep2';", dep2: "dep2"`
					);
					await promises.writeFile('test/_tmp/input/dep2.js', 'export default "next";');
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(
						run('../_tmp/output/bundle.js'),
						`dep1: "export default "next";", dep2: "next"`
					);
				}
			]);
		});

		it('respects changed watched directories in the transform hook', async () => {
			const WATCHED_ID = resolve('test/_tmp/input/watched');
			await copy('test/watch/samples/watch-files', 'test/_tmp/input');
			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					async transform() {
						this.addWatchFile('test/_tmp/input');
						return `export default ${await pathExists(WATCHED_ID)}`;
					}
				}
			});
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), true);
					await promises.unlink(WATCHED_ID);
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), false);
					watcher.close();
				}
			]);
		});

		it('respects initially missing added watched files', async () => {
			await copy('test/watch/samples/basic', 'test/_tmp/input');
			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					async transform() {
						this.addWatchFile('test/_tmp/input/dep');
						return `export default ${await pathExists('test/_tmp/input/dep')}`;
					}
				}
			});
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), false);
					await promises.writeFile('test/_tmp/input/dep', '');
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), true);
				}
			]);
		});

		it('respects unlinked and re-added watched files', async () => {
			await copy('test/watch/samples/basic', 'test/_tmp/input');
			await promises.writeFile('test/_tmp/input/dep', '');
			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					async transform() {
						this.addWatchFile('test/_tmp/input/dep');
						return `export default ${await pathExists('test/_tmp/input/dep')}`;
					}
				}
			});
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), true);
					await promises.unlink('test/_tmp/input/dep');
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), false);
					await promises.writeFile('test/_tmp/input/dep', '');
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(run('../_tmp/output/bundle.js'), true);
				}
			]);
		});

		it('does not rerun the transform hook if a non-watched change triggered the re-run', async () => {
			const WATCHED_ID = resolve('test/_tmp/input/watched');
			let transformRuns = 0;
			await copy('test/watch/samples/watch-files', 'test/_tmp/input');
			await wait(100);
			await promises.writeFile('test/_tmp/input/alsoWatched', 'initial');
			watcher = rollup.watch({
				input: 'test/_tmp/input/main.js',
				output: {
					file: 'test/_tmp/output/bundle.js',
					format: 'cjs',
					exports: 'auto'
				},
				plugins: {
					buildStart() {
						this.addWatchFile('test/_tmp/input/alsoWatched');
					},
					async transform() {
						transformRuns++;
						this.addWatchFile(WATCHED_ID);
						return `export default "${(await promises.readFile(WATCHED_ID, 'utf8')).trim()}"`;
					}
				}
			});
			return sequence(watcher, [
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				async () => {
					assert.strictEqual(transformRuns, 1);
					await promises.writeFile('test/_tmp/input/alsoWatched', 'next');
				},
				'START',
				'BUNDLE_START',
				'BUNDLE_END',
				'END',
				() => {
					assert.strictEqual(transformRuns, 1);
				}
			]);
		});
	});
}).timeout(20000);