rollup 2.77.2 → 2.78.1

package/dist/rollup.d.ts

@@ -244,7 +244,7 @@ export type ResolveIdHook = (
 	source: string,
 	importer: string | undefined,
 	options: { custom?: CustomPluginOptions; isEntry: boolean }
-) => Promise<ResolveIdResult> | ResolveIdResult;
+) => ResolveIdResult;
 
 export type ShouldTransformCachedModuleHook = (
 	this: PluginContext,
@@ -257,7 +257,7 @@ export type ShouldTransformCachedModuleHook = (
 		resolvedSources: ResolvedIdMap;
 		syntheticNamedExports: boolean | string;
 	}
-) => Promise<boolean> | boolean;
+) => boolean;
 
 export type IsExternal = (
 	source: string,
@@ -269,9 +269,9 @@ export type IsPureModule = (id: string) => boolean | null | void;
 
 export type HasModuleSideEffects = (id: string, external: boolean) => boolean;
 
-type LoadResult = SourceDescription | string | null | void;
+export type LoadResult = SourceDescription | string | null | void;
 
-export type LoadHook = (this: PluginContext, id: string) => Promise<LoadResult> | LoadResult;
+export type LoadHook = (this: PluginContext, id: string) => LoadResult;
 
 export interface TransformPluginContext extends PluginContext {
 	getCombinedSourcemap: () => SourceMap;
@@ -283,27 +283,22 @@ export type TransformHook = (
 	this: TransformPluginContext,
 	code: string,
 	id: string
-) => Promise<TransformResult> | TransformResult;
+) => TransformResult;
 
-export type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => Promise<void> | void;
+export type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => void;
 
 export type RenderChunkHook = (
 	this: PluginContext,
 	code: string,
 	chunk: RenderedChunk,
 	options: NormalizedOutputOptions
-) =>
-	| Promise<{ code: string; map?: SourceMapInput } | null>
-	| { code: string; map?: SourceMapInput }
-	| string
-	| null
-	| undefined;
+) => { code: string; map?: SourceMapInput } | string | null | undefined;
 
 export type ResolveDynamicImportHook = (
 	this: PluginContext,
 	specifier: string | AcornNode,
 	importer: string
-) => Promise<ResolveIdResult> | ResolveIdResult;
+) => ResolveIdResult;
 
 export type ResolveImportMetaHook = (
 	this: PluginContext,
@@ -344,7 +339,7 @@ export type WatchChangeHook = (
 	this: PluginContext,
 	id: string,
 	change: { event: ChangeEvent }
-) => Promise<void> | void;
+) => void;
 
 /**
  * use this type for plugin annotation
@@ -371,32 +366,21 @@ export interface OutputBundleWithPlaceholders {
 	[fileName: string]: OutputAsset | OutputChunk | FilePlaceholder;
 }
 
-export interface PluginHooks extends OutputPluginHooks {
-	buildEnd: (this: PluginContext, err?: Error) => Promise<void> | void;
-	buildStart: (this: PluginContext, options: NormalizedInputOptions) => Promise<void> | void;
-	closeBundle: (this: PluginContext) => Promise<void> | void;
-	closeWatcher: (this: PluginContext) => Promise<void> | void;
-	load: LoadHook;
-	moduleParsed: ModuleParsedHook;
-	options: (
-		this: MinimalPluginContext,
-		options: InputOptions
-	) => Promise<InputOptions | null | void> | InputOptions | null | void;
-	resolveDynamicImport: ResolveDynamicImportHook;
-	resolveId: ResolveIdHook;
-	shouldTransformCachedModule: ShouldTransformCachedModuleHook;
-	transform: TransformHook;
-	watchChange: WatchChangeHook;
-}
-
-interface OutputPluginHooks {
+export interface FunctionPluginHooks {
 	augmentChunkHash: (this: PluginContext, chunk: PreRenderedChunk) => string | void;
+	buildEnd: (this: PluginContext, err?: Error) => void;
+	buildStart: (this: PluginContext, options: NormalizedInputOptions) => void;
+	closeBundle: (this: PluginContext) => void;
+	closeWatcher: (this: PluginContext) => void;
 	generateBundle: (
 		this: PluginContext,
 		options: NormalizedOutputOptions,
 		bundle: OutputBundle,
 		isWrite: boolean
-	) => void | Promise<void>;
+	) => void;
+	load: LoadHook;
+	moduleParsed: ModuleParsedHook;
+	options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | null | void;
 	outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | null | void;
 	renderChunk: RenderChunkHook;
 	renderDynamicImport: (
@@ -408,45 +392,52 @@ interface OutputPluginHooks {
 			targetModuleId: string | null;
 		}
 	) => { left: string; right: string } | null | void;
-	renderError: (this: PluginContext, err?: Error) => Promise<void> | void;
+	renderError: (this: PluginContext, err?: Error) => void;
 	renderStart: (
 		this: PluginContext,
 		outputOptions: NormalizedOutputOptions,
 		inputOptions: NormalizedInputOptions
-	) => Promise<void> | void;
+	) => void;
 	/** @deprecated Use `resolveFileUrl` instead */
 	resolveAssetUrl: ResolveAssetUrlHook;
+	resolveDynamicImport: ResolveDynamicImportHook;
 	resolveFileUrl: ResolveFileUrlHook;
+	resolveId: ResolveIdHook;
 	resolveImportMeta: ResolveImportMetaHook;
+	shouldTransformCachedModule: ShouldTransformCachedModuleHook;
+	transform: TransformHook;
+	watchChange: WatchChangeHook;
 	writeBundle: (
 		this: PluginContext,
 		options: NormalizedOutputOptions,
 		bundle: OutputBundle
-	) => void | Promise<void>;
+	) => void;
 }
 
-export type AsyncPluginHooks =
-	| 'options'
-	| 'buildEnd'
-	| 'buildStart'
+export type OutputPluginHooks =
+	| 'augmentChunkHash'
 	| 'generateBundle'
-	| 'load'
-	| 'moduleParsed'
+	| 'outputOptions'
 	| 'renderChunk'
+	| 'renderDynamicImport'
 	| 'renderError'
 	| 'renderStart'
-	| 'resolveDynamicImport'
-	| 'resolveId'
-	| 'shouldTransformCachedModule'
-	| 'transform'
-	| 'writeBundle'
-	| 'closeBundle'
-	| 'closeWatcher'
-	| 'watchChange';
+	| 'resolveAssetUrl'
+	| 'resolveFileUrl'
+	| 'resolveImportMeta'
+	| 'writeBundle';
+
+export type InputPluginHooks = Exclude<keyof FunctionPluginHooks, OutputPluginHooks>;
 
-export type PluginValueHooks = 'banner' | 'footer' | 'intro' | 'outro';
+export type SyncPluginHooks =
+	| 'augmentChunkHash'
+	| 'outputOptions'
+	| 'renderDynamicImport'
+	| 'resolveAssetUrl'
+	| 'resolveFileUrl'
+	| 'resolveImportMeta';
 
-export type SyncPluginHooks = Exclude<keyof PluginHooks, AsyncPluginHooks>;
+export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
 
 export type FirstPluginHooks =
 	| 'load'
@@ -466,37 +457,38 @@ export type SequentialPluginHooks =
 	| 'renderChunk'
 	| 'transform';
 
-export type ParallelPluginHooks =
-	| 'banner'
-	| 'buildEnd'
-	| 'buildStart'
-	| 'footer'
-	| 'intro'
-	| 'moduleParsed'
-	| 'outro'
-	| 'renderError'
-	| 'renderStart'
-	| 'writeBundle'
-	| 'closeBundle'
-	| 'closeWatcher'
-	| 'watchChange';
+export type ParallelPluginHooks = Exclude<
+	keyof FunctionPluginHooks | AddonHooks,
+	FirstPluginHooks | SequentialPluginHooks
+>;
 
-interface OutputPluginValueHooks {
-	banner: AddonHook;
-	cacheKey: string;
-	footer: AddonHook;
-	intro: AddonHook;
-	outro: AddonHook;
-}
+export type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro';
 
-export interface Plugin extends Partial<PluginHooks>, Partial<OutputPluginValueHooks> {
-	// for inter-plugin communication
-	api?: any;
+type MakeAsync<Fn> = Fn extends (this: infer This, ...args: infer Args) => infer Return
+	? (this: This, ...args: Args) => Return | Promise<Return>
+	: never;
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type ObjectHook<T, O = {}> = T | ({ handler: T; order?: 'pre' | 'post' | null } & O);
+
+export type PluginHooks = {
+	[K in keyof FunctionPluginHooks]: ObjectHook<
+		K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K],
+		// eslint-disable-next-line @typescript-eslint/ban-types
+		K extends ParallelPluginHooks ? { sequential?: boolean } : {}
+	>;
+};
+
+export interface OutputPlugin
+	extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>,
+		Partial<{ [K in AddonHooks]: ObjectHook<AddonHook> }> {
+	cacheKey?: string;
 	name: string;
 }
 
-export interface OutputPlugin extends Partial<OutputPluginHooks>, Partial<OutputPluginValueHooks> {
-	name: string;
+export interface Plugin extends OutputPlugin, Partial<PluginHooks> {
+	// for inter-plugin communication
+	api?: any;
 }
 
 type TreeshakingPreset = 'smallest' | 'safest' | 'recommended';

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.2
-	Wed, 27 Jul 2022 05:18:41 GMT - commit 22b2f68aa8638ffaac4de69011e10480f5d50546
+	Rollup.js v2.78.1
+	Fri, 19 Aug 2022 05:19:43 GMT - commit 398d0c4970b679795025f36e320f8aecb2859d24
 
 	https://github.com/rollup/rollup
 

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.2
-	Wed, 27 Jul 2022 05:18:41 GMT - commit 22b2f68aa8638ffaac4de69011e10480f5d50546
+	Rollup.js v2.78.1
+	Fri, 19 Aug 2022 05:19:43 GMT - commit 398d0c4970b679795025f36e320f8aecb2859d24
 
 	https://github.com/rollup/rollup
 

package/dist/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.2
-	Wed, 27 Jul 2022 05:18:41 GMT - commit 22b2f68aa8638ffaac4de69011e10480f5d50546
+	Rollup.js v2.78.1
+	Fri, 19 Aug 2022 05:19:43 GMT - commit 398d0c4970b679795025f36e320f8aecb2859d24
 
 	https://github.com/rollup/rollup
 

package/dist/shared/mergeOptions.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.2
-	Wed, 27 Jul 2022 05:18:41 GMT - commit 22b2f68aa8638ffaac4de69011e10480f5d50546
+	Rollup.js v2.78.1
+	Fri, 19 Aug 2022 05:19:43 GMT - commit 398d0c4970b679795025f36e320f8aecb2859d24
 
 	https://github.com/rollup/rollup
 

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.2
-	Wed, 27 Jul 2022 05:18:41 GMT - commit 22b2f68aa8638ffaac4de69011e10480f5d50546
+	Rollup.js v2.78.1
+	Fri, 19 Aug 2022 05:19:43 GMT - commit 398d0c4970b679795025f36e320f8aecb2859d24
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.77.2";
+var version$1 = "2.78.1";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -373,6 +373,22 @@ function errInvalidOption(option, urlHash, explanation, value) {
         url: `https://rollupjs.org/guide/en/#${urlHash}`
     };
 }
+function errInvalidAddonPluginHook(hook, plugin) {
+    return {
+        code: Errors.INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook ${hook} for plugin ${plugin}, expected a string, a function hook or an object with a "handler" string or function.`,
+        plugin
+    };
+}
+function errInvalidFunctionPluginHook(hook, plugin) {
+    return {
+        code: Errors.INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook ${hook} for plugin ${plugin}, expected a function hook or an object with a "handler" function.`,
+        plugin
+    };
+}
 function errInvalidRollupPhaseForAddWatchFile() {
     return {
         code: Errors.INVALID_ROLLUP_PHASE,
@@ -2410,15 +2426,16 @@ const RESERVED_NAMES$1 = RESERVED_NAMES;
 
 const illegalCharacters = /[^$_a-zA-Z0-9]/g;
 const startsWithDigit = (str) => /\d/.test(str[0]);
+const needsEscape = (str) => startsWithDigit(str) || RESERVED_NAMES$1.has(str) || str === 'arguments';
 function isLegal(str) {
-    if (startsWithDigit(str) || RESERVED_NAMES$1.has(str)) {
+    if (needsEscape(str)) {
         return false;
     }
     return !illegalCharacters.test(str);
 }
 function makeLegal(str) {
     str = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(illegalCharacters, '_');
-    if (startsWithDigit(str) || RESERVED_NAMES$1.has(str))
+    if (needsEscape(str))
         str = `_${str}`;
     return str || '_';
 }
@@ -14735,7 +14752,7 @@ class Chunk {
             });
             const currentPath = `${currentDir}/${fileName}`;
             const { preserveModulesRoot } = options;
-            if (preserveModulesRoot && currentPath.startsWith(preserveModulesRoot)) {
+            if (preserveModulesRoot && require$$0.resolve(currentPath).startsWith(preserveModulesRoot)) {
                 path = currentPath.slice(preserveModulesRoot.length).replace(/^[\\/]/, '');
             }
             else {
@@ -22602,7 +22619,7 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
     else {
         cacheInstance = getCacheForUncacheablePlugin(plugin.name);
     }
-    const context = {
+    return {
         addWatchFile(id) {
             if (graph.phase >= BuildPhase.GENERATE) {
                 return this.error(errInvalidRollupPhaseForAddWatchFile());
@@ -22660,9 +22677,9 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
             options.onwarn(warning);
         }
     };
-    return context;
 }
 
+// This will make sure no input hook is omitted
 const inputHookNames = {
     buildEnd: 1,
     buildStart: 1,
@@ -22678,19 +22695,14 @@ const inputHookNames = {
     watchChange: 1
 };
 const inputHooks = Object.keys(inputHookNames);
-function throwInvalidHookError(hookName, pluginName) {
-    return error({
-        code: 'INVALID_PLUGIN_HOOK',
-        message: `Error running plugin hook ${hookName} for ${pluginName}, expected a function hook.`
-    });
-}
 class PluginDriver {
     constructor(graph, options, userPlugins, pluginCache, basePluginDriver) {
         this.graph = graph;
         this.options = options;
+        this.pluginCache = pluginCache;
+        this.sortedPlugins = new Map();
         this.unfulfilledActions = new Set();
         warnDeprecatedHooks(userPlugins, options);
-        this.pluginCache = pluginCache;
         this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
         this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
         this.getFileName = this.fileEmitter.getFileName.bind(this.fileEmitter);
@@ -22720,21 +22732,21 @@ class PluginDriver {
     }
     // chains, first non-null result stops and returns
     hookFirst(hookName, args, replaceContext, skipped) {
-        let promise = Promise.resolve(undefined);
-        for (const plugin of this.plugins) {
+        let promise = Promise.resolve(null);
+        for (const plugin of this.getSortedPlugins(hookName)) {
             if (skipped && skipped.has(plugin))
                 continue;
             promise = promise.then(result => {
                 if (result != null)
                     return result;
-                return this.runHook(hookName, args, plugin, false, replaceContext);
+                return this.runHook(hookName, args, plugin, replaceContext);
             });
         }
         return promise;
     }
     // chains synchronously, first non-null result stops and returns
     hookFirstSync(hookName, args, replaceContext) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             if (result != null)
                 return result;
@@ -22742,56 +22754,58 @@ class PluginDriver {
         return null;
     }
     // parallel, ignores returns
-    hookParallel(hookName, args, replaceContext) {
-        const promises = [];
-        for (const plugin of this.plugins) {
-            const hookPromise = this.runHook(hookName, args, plugin, false, replaceContext);
-            if (!hookPromise)
-                continue;
-            promises.push(hookPromise);
+    async hookParallel(hookName, args, replaceContext) {
+        const parallelPromises = [];
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            if (plugin[hookName].sequential) {
+                await Promise.all(parallelPromises);
+                parallelPromises.length = 0;
+                await this.runHook(hookName, args, plugin, replaceContext);
+            }
+            else {
+                parallelPromises.push(this.runHook(hookName, args, plugin, replaceContext));
+            }
         }
-        return Promise.all(promises).then(() => { });
+        await Promise.all(parallelPromises);
     }
     // chains, reduces returned value, handling the reduced value as the first hook argument
     hookReduceArg0(hookName, [arg0, ...rest], reduce, replaceContext) {
         let promise = Promise.resolve(arg0);
-        for (const plugin of this.plugins) {
-            promise = promise.then(arg0 => {
-                const args = [arg0, ...rest];
-                const hookPromise = this.runHook(hookName, args, plugin, false, replaceContext);
-                if (!hookPromise)
-                    return arg0;
-                return hookPromise.then(result => reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin));
-            });
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(arg0 => this.runHook(hookName, [arg0, ...rest], plugin, replaceContext).then(result => reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin)));
         }
         return promise;
     }
     // chains synchronously, reduces returned value, handling the reduced value as the first hook argument
     hookReduceArg0Sync(hookName, [arg0, ...rest], reduce, replaceContext) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const args = [arg0, ...rest];
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             arg0 = reduce.call(this.pluginContexts.get(plugin), arg0, result, plugin);
         }
         return arg0;
     }
-    // chains, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
-    hookReduceValue(hookName, initialValue, args, reduce, replaceContext) {
-        let promise = Promise.resolve(initialValue);
-        for (const plugin of this.plugins) {
-            promise = promise.then(value => {
-                const hookPromise = this.runHook(hookName, args, plugin, true, replaceContext);
-                if (!hookPromise)
-                    return value;
-                return hookPromise.then(result => reduce.call(this.pluginContexts.get(plugin), value, result, plugin));
-            });
+    // chains, reduces returned value to type string, handling the reduced value separately. permits hooks as values.
+    async hookReduceValue(hookName, initialValue, args, reducer) {
+        const results = [];
+        const parallelResults = [];
+        for (const plugin of this.getSortedPlugins(hookName, validateAddonPluginHandler)) {
+            if (plugin[hookName].sequential) {
+                results.push(...(await Promise.all(parallelResults)));
+                parallelResults.length = 0;
+                results.push(await this.runHook(hookName, args, plugin));
+            }
+            else {
+                parallelResults.push(this.runHook(hookName, args, plugin));
+            }
         }
-        return promise;
+        results.push(...(await Promise.all(parallelResults)));
+        return results.reduce(reducer, await initialValue);
     }
     // chains synchronously, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
     hookReduceValueSync(hookName, initialValue, args, reduce, replaceContext) {
         let acc = initialValue;
-        for (const plugin of this.plugins) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
             const result = this.runHookSync(hookName, args, plugin, replaceContext);
             acc = reduce.call(this.pluginContexts.get(plugin), acc, result, plugin);
         }
@@ -22800,31 +22814,32 @@ class PluginDriver {
     // chains, ignores returns
     hookSeq(hookName, args, replaceContext) {
         let promise = Promise.resolve();
-        for (const plugin of this.plugins) {
-            promise = promise.then(() => this.runHook(hookName, args, plugin, false, replaceContext));
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(() => this.runHook(hookName, args, plugin, replaceContext));
         }
-        return promise;
+        return promise.then(noReturn);
+    }
+    getSortedPlugins(hookName, validateHandler) {
+        return getOrCreate(this.sortedPlugins, hookName, () => getSortedValidatedPlugins(hookName, this.plugins, validateHandler));
     }
-    runHook(hookName, args, plugin, permitValues, hookContext) {
+    // Implementation signature
+    runHook(hookName, args, plugin, replaceContext) {
+        // We always filter for plugins that support the hook before running it
         const hook = plugin[hookName];
-        if (!hook)
-            return undefined;
+        const handler = typeof hook === 'object' ? hook.handler : hook;
         let context = this.pluginContexts.get(plugin);
-        if (hookContext) {
-            context = hookContext(context, plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
         }
         let action = null;
         return Promise.resolve()
             .then(() => {
-            // permit values allows values to be returned instead of a functional hook
-            if (typeof hook !== 'function') {
-                if (permitValues)
-                    return hook;
-                return throwInvalidHookError(hookName, plugin.name);
+            if (typeof handler !== 'function') {
+                return handler;
             }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            const hookResult = hook.apply(context, args);
-            if (!hookResult || !hookResult.then) {
+            const hookResult = handler.apply(context, args);
+            if (!(hookResult === null || hookResult === void 0 ? void 0 : hookResult.then)) {
                 // short circuit for non-thenables and non-Promises
                 return hookResult;
             }
@@ -22857,29 +22872,61 @@ class PluginDriver {
      * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
      * @param args Arguments passed to the plugin hook.
      * @param plugin The acutal plugin
-     * @param hookContext When passed, the plugin context can be overridden.
+     * @param replaceContext When passed, the plugin context can be overridden.
      */
-    runHookSync(hookName, args, plugin, hookContext) {
+    runHookSync(hookName, args, plugin, replaceContext) {
         const hook = plugin[hookName];
-        if (!hook)
-            return undefined;
+        const handler = typeof hook === 'object' ? hook.handler : hook;
         let context = this.pluginContexts.get(plugin);
-        if (hookContext) {
-            context = hookContext(context, plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
         }
         try {
-            // permit values allows values to be returned instead of a functional hook
-            if (typeof hook !== 'function') {
-                return throwInvalidHookError(hookName, plugin.name);
-            }
             // eslint-disable-next-line @typescript-eslint/ban-types
-            return hook.apply(context, args);
+            return handler.apply(context, args);
         }
         catch (err) {
             return throwPluginError(err, plugin.name, { hook: hookName });
         }
     }
 }
+function getSortedValidatedPlugins(hookName, plugins, validateHandler = validateFunctionPluginHandler) {
+    const pre = [];
+    const normal = [];
+    const post = [];
+    for (const plugin of plugins) {
+        const hook = plugin[hookName];
+        if (hook) {
+            if (typeof hook === 'object') {
+                validateHandler(hook.handler, hookName, plugin);
+                if (hook.order === 'pre') {
+                    pre.push(plugin);
+                    continue;
+                }
+                if (hook.order === 'post') {
+                    post.push(plugin);
+                    continue;
+                }
+            }
+            else {
+                validateHandler(hook, hookName, plugin);
+            }
+            normal.push(plugin);
+        }
+    }
+    return [...pre, ...normal, ...post];
+}
+function validateFunctionPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'function') {
+        error(errInvalidFunctionPluginHook(hookName, plugin.name));
+    }
+}
+function validateAddonPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'string' && typeof handler !== 'function') {
+        return error(errInvalidAddonPluginHook(hookName, plugin.name));
+    }
+}
+function noReturn() { }
 
 class Queue {
     constructor(maxParallel) {
@@ -23720,17 +23767,15 @@ async function getInputOptions(rawInputOptions, watchMode) {
     if (!rawInputOptions) {
         throw new Error('You must supply an options object to rollup');
     }
-    const rawPlugins = ensureArray$1(rawInputOptions.plugins);
+    const rawPlugins = getSortedValidatedPlugins('options', ensureArray$1(rawInputOptions.plugins));
     const { options, unsetOptions } = normalizeInputOptions(await rawPlugins.reduce(applyOptionHook(watchMode), Promise.resolve(rawInputOptions)));
     normalizePlugins(options.plugins, ANONYMOUS_PLUGIN_PREFIX);
     return { options, unsetOptions };
 }
 function applyOptionHook(watchMode) {
     return async (inputOptions, plugin) => {
-        if (plugin.options) {
-            return ((await plugin.options.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) || inputOptions);
-        }
-        return inputOptions;
+        const handler = 'handler' in plugin.options ? plugin.options.handler : plugin.options;
+        return ((await handler.call({ meta: { rollupVersion: version$1, watchMode } }, await inputOptions)) || inputOptions);
     };
 }
 function normalizePlugins(plugins, anonymousPrefix) {

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.77.2
-	Wed, 27 Jul 2022 05:18:41 GMT - commit 22b2f68aa8638ffaac4de69011e10480f5d50546
+	Rollup.js v2.78.1
+	Fri, 19 Aug 2022 05:19:43 GMT - commit 398d0c4970b679795025f36e320f8aecb2859d24
 
 	https://github.com/rollup/rollup