augmentChunkHash plugin hook

src/Chunk.ts

@@ -124,6 +124,7 @@ export default class Chunk {
 		return chunk;
 	}
 
+	augmentedHash?: string;
 	entryModules: Module[] = [];
 	execIndex: number;
 	exportMode = 'named';
@@ -325,6 +326,9 @@ export default class Chunk {
 		if (this.renderedHash) return this.renderedHash;
 		if (!this.renderedSource) return '';
 		const hash = sha256();
+		if (this.augmentedHash) {
+			hash.update(this.augmentedHash);
+		}
 		hash.update(this.renderedSource.toString());
 		hash.update(
 			this.getExportNames()
@@ -799,7 +803,6 @@ export default class Chunk {
 
 	private computeContentHashWithDependencies(addons: Addons, options: OutputOptions): string {
 		const hash = sha256();
-
 		hash.update(
 			[addons.intro, addons.outro, addons.banner, addons.footer].map(addon => addon || '').join(':')
 		);

src/rollup/index.ts

@@ -22,6 +22,7 @@ import {
 	OutputOptions,
 	Plugin,
 	PluginContext,
+	PreRenderedChunk,
 	RollupBuild,
 	RollupCache,
 	RollupOutput,
@@ -211,45 +212,81 @@ export default function rollup(rawInputOptions: GenericConfigObject): Promise<Ro
 								optimized = true;
 							}
 
-							assignChunkIds(chunks, inputOptions, outputOptions, inputBase, addons);
-
-							// assign to outputBundle
-							for (let i = 0; i < chunks.length; i++) {
-								const chunk = chunks[i];
-								const facadeModule = chunk.facadeModule;
-
-								outputBundle[chunk.id] = {
-									code: undefined as any,
-									dynamicImports: chunk.getDynamicImportIds(),
-									exports: chunk.getExportNames(),
-									facadeModuleId: facadeModule && facadeModule.id,
-									fileName: chunk.id,
-									imports: chunk.getImportIds(),
-									isDynamicEntry:
-										facadeModule !== null && facadeModule.dynamicallyImportedBy.length > 0,
-									isEntry: facadeModule !== null && facadeModule.isEntryPoint,
-									map: undefined,
-									modules: chunk.renderedModules,
-									get name() {
-										return chunk.getChunkName();
-									}
-								} as OutputChunk;
-							}
-
 							return Promise.all(
 								chunks.map(chunk => {
-									const outputChunk = outputBundle[chunk.id] as OutputChunk;
-									return chunk.render(outputOptions, addons, outputChunk).then(rendered => {
-										outputChunk.code = rendered.code;
-										outputChunk.map = rendered.map;
-
-										return graph.pluginDriver.hookParallel('ongenerate', [
-											{ bundle: outputChunk, ...outputOptions },
-											outputChunk
-										]);
-									});
+									const facadeModule = chunk.facadeModule;
+									const chunkInfo = {
+										dynamicImports: chunk.getDynamicImportIds(),
+										exports: chunk.getExportNames(),
+										facadeModuleId: facadeModule && facadeModule.id,
+										imports: chunk.getImportIds(),
+										isDynamicEntry:
+											facadeModule !== null && facadeModule.dynamicallyImportedBy.length > 0,
+										isEntry: facadeModule !== null && facadeModule.isEntryPoint,
+										modules: chunk.renderedModules,
+										get name() {
+											return chunk.getChunkName();
+										}
+									} as PreRenderedChunk;
+									return graph.pluginDriver
+										.hookReduceValue(
+											'augmentChunkHash',
+											'',
+											[chunkInfo],
+											(hashForChunk, pluginHash) => {
+												if (pluginHash) {
+													hashForChunk += pluginHash;
+												}
+												return hashForChunk;
+											}
+										)
+										.then(hashForChunk => {
+											if (hashForChunk) {
+												chunk.augmentedHash = hashForChunk;
+											}
+										});
 								})
-							).then(() => {});
+							).then(() => {
+								assignChunkIds(chunks, inputOptions, outputOptions, inputBase, addons);
+
+								// assign to outputBundle
+								for (let i = 0; i < chunks.length; i++) {
+									const chunk = chunks[i];
+									const facadeModule = chunk.facadeModule;
+
+									outputBundle[chunk.id] = {
+										code: undefined as any,
+										dynamicImports: chunk.getDynamicImportIds(),
+										exports: chunk.getExportNames(),
+										facadeModuleId: facadeModule && facadeModule.id,
+										fileName: chunk.id,
+										imports: chunk.getImportIds(),
+										isDynamicEntry:
+											facadeModule !== null && facadeModule.dynamicallyImportedBy.length > 0,
+										isEntry: facadeModule !== null && facadeModule.isEntryPoint,
+										map: undefined,
+										modules: chunk.renderedModules,
+										get name() {
+											return chunk.getChunkName();
+										}
+									} as OutputChunk;
+								}
+
+								return Promise.all(
+									chunks.map(chunk => {
+										const outputChunk = outputBundle[chunk.id] as OutputChunk;
+										return chunk.render(outputOptions, addons, outputChunk).then(rendered => {
+											outputChunk.code = rendered.code;
+											outputChunk.map = rendered.map;
+
+											return graph.pluginDriver.hookParallel('ongenerate', [
+												{ bundle: outputChunk, ...outputOptions },
+												outputChunk
+											]);
+										});
+									})
+								).then(() => {});
+							});
 						})
 						.catch(error =>
 							graph.pluginDriver.hookParallel('renderError', [error]).then(() => {

src/rollup/types.d.ts

@@ -276,6 +276,7 @@ interface OnWriteOptions extends OutputOptions {
 }
 
 export interface PluginHooks {
+	augmentChunkHash: (this: PluginContext, chunk: PreOutputChunk) => void;
 	buildEnd: (this: PluginContext, err?: Error) => Promise<void> | void;
 	buildStart: (this: PluginContext, options: InputOptions) => Promise<void> | void;
 	generateBundle: (
@@ -446,11 +447,10 @@ export interface RenderedModule {
 	renderedLength: number;
 }
 
-export interface RenderedChunk {
+export interface PreRenderedChunk {
 	dynamicImports: string[];
 	exports: string[];
 	facadeModuleId: string | null;
-	fileName: string;
 	imports: string[];
 	isDynamicEntry: boolean;
 	isEntry: boolean;
@@ -460,6 +460,10 @@ export interface RenderedChunk {
 	name: string;
 }
 
+export interface RenderedChunk extends PreRenderedChunk {
+	fileName: string;
+}
+
 export interface OutputChunk extends RenderedChunk {
 	code: string;
 	map?: SourceMap;

test/hooks/index.js

@@ -1328,4 +1328,157 @@ module.exports = input;
 				]);
 			});
 	});
+	it('supports augmentChunkHash hook', () => {
+		let augmentChunkHashCalls = 0;
+		return rollup
+			.rollup({
+				input: 'input',
+				plugins: [
+					loader({
+						input: `alert('hello')`
+					}),
+					{
+						augmentChunkHash(update) {
+							augmentChunkHashCalls++;
+							assert(this.meta);
+							assert(this.meta.rollupVersion);
+						}
+					}
+				]
+			})
+			.then(bundle =>
+				bundle.generate({
+					format: 'esm',
+					dir: 'dist',
+					entryFileNames: '[name]-[hash].js'
+				})
+			)
+			.then(output => {
+				assert.equal(augmentChunkHashCalls, 1);
+			});
+	});
+	it('augments the chunk hash when the update function is called within the augmentChunkHash hook', () => {
+		const inputCode = `alert('hello')`;
+		const outputOptions = {
+			format: 'esm',
+			dir: 'dist',
+			entryFileNames: '[name]-[hash].js'
+		};
+		function getFileName(bundle) {
+			return bundle.generate(outputOptions).then(({ output }) => {
+				return output[0].fileName;
+			});
+		}
+		function bundleWithoutAugment() {
+			return rollup
+				.rollup({
+					input: 'input',
+					plugins: [
+						loader({
+							input: inputCode
+						})
+					]
+				})
+				.then(getFileName);
+		}
+		function bundleWithAugment() {
+			return rollup
+				.rollup({
+					input: 'input',
+					plugins: [
+						loader({
+							input: inputCode
+						}),
+						{
+							augmentChunkHash() {
+								return 'foo';
+							}
+						}
+					]
+				})
+				.then(getFileName);
+		}
+		return Promise.all([bundleWithoutAugment(), bundleWithAugment()]).then(([base, augmented]) => {
+			assert.notEqual(base, augmented);
+		});
+	});
+	it('propagates hash updates of augmentChunkHash to all dependents', () => {
+		return rollup
+			.rollup({
+				input: 'input',
+				plugins: [
+					loader({
+						input: `console.log('input');import('other');`,
+						other: `console.log('other');`
+					}),
+					{
+						augmentChunkHash() {
+							return Promise.resolve('foo');
+						}
+					}
+				]
+			})
+			.then(bundle =>
+				bundle.generate({
+					format: 'esm',
+					dir: 'dist',
+					entryFileNames: '[name]-[hash].js',
+					chunkFileNames: '[name]-[hash].js'
+				})
+			)
+			.then(({ output }) => {
+				const importedFileName = output[0].dynamicImports[0];
+				const otherFileName = output[1].fileName;
+				assert.equal(otherFileName, importedFileName);
+			});
+	});
+	it('augmentChunkHash only takes effect for chunks whose call got a return value', () => {
+		const outputOptions = {
+			format: 'esm',
+			dir: 'dist',
+			entryFileNames: '[name]-[hash].js'
+		};
+		const input = ['input', 'other'];
+		const inputCode = {
+			input: `console.log('input');`,
+			other: `console.log('other');`
+		};
+		function getFileNamesForChunks(bundle) {
+			return bundle.generate(outputOptions).then(({ output }) => {
+				return output.reduce((result, chunk) => {
+					result[chunk.name] = chunk.fileName;
+					return result;
+				}, {});
+			});
+		}
+		function bundleWithoutAugment() {
+			return rollup
+				.rollup({
+					input,
+					plugins: [loader(inputCode)]
+				})
+				.then(getFileNamesForChunks);
+		}
+		function bundleWithAugment() {
+			return rollup
+				.rollup({
+					input,
+					plugins: [
+						loader(inputCode),
+						{
+							augmentChunkHash(chunk) {
+								if (chunk.name === 'input') {
+									return 'foo';
+								}
+							}
+						}
+					]
+				})
+				.then(getFileNamesForChunks);
+		}
+		return Promise.all([bundleWithoutAugment(), bundleWithAugment()]).then(([base, augmented]) => {
+			assert.notEqual(base.input, augmented.input);
+			assert.equal(base.other, augmented.other);
+		});
+	});
 });