@rollup-extras/plugin-serve 2.3.1 → 2.4.1

package/README.md

@@ -66,15 +66,15 @@ Option to use `writeBundle` hook instead of `generateBundle`.
 
 Optional, `boolean`, default: `false`.
 
-When enabled, serves all emitted assets directly from memory instead of from disk. This is similar to how webpack-dev-server works — Rollup output never needs to hit the filesystem.
+When enabled, serves all emitted assets directly from memory instead of from disk. This controls how files are served; Rollup still writes output when run with `rollup -cw`.
 
 When `inMemory` is `true`, the plugin automatically uses the `generateBundle` hook (regardless of `useWriteBundle`) to capture all chunks and assets in memory. A custom Hono middleware serves these files before falling through to any disk-based static serving configured via `dirs`.
 
-For a fully disk-free dev server, set `watch: { skipWrite: true }` in your Rollup config to prevent Rollup from writing files to disk. The plugin does not force this — you control it.
+For disk-free Rollup output, use the package's [`/watch` helper](#in-memory-serving). Setting `watch: { skipWrite: true }` with Rollup's ordinary watcher skips output generation as well as writing, so the plugin receives no files to serve.
 
 **Limitations:**
 - Only covers Rollup's own output. Other plugins (e.g., plugin-copy, plugin-html) may still perform disk I/O independently.
-- Plugins that only use the `writeBundle` hook won't participate when `skipWrite` is enabled.
+- Plugins that only use the `writeBundle` hook won't participate with the `/watch` helper. Configure plugins such as plugin-html to use `generateBundle` when their output should be served from memory.
 
 ### dirs
 
@@ -138,6 +138,8 @@ Set to `false` (or leave unset) to disable both the endpoint and the script inje
 
 ## In-Memory Serving
 
+Keep the Rollup configuration in `rollup.config.js`:
+
 ```javascript
 import serve from "@rollup-extras/plugin-serve";
 
@@ -147,13 +149,34 @@ export default {
     format: "es",
     dir: "dest",
   },
-  watch: {
-    skipWrite: true, // recommended: avoid writing files to disk
-  },
   plugins: [serve({ inMemory: true })],
 };
 ```
 
+Create `dev.js` to start a watcher that generates output without writing it to disk:
+
+```javascript
+import watch from "@rollup-extras/plugin-serve/watch";
+import config from "./rollup.config.js";
+
+const watcher = watch(config);
+
+watcher.on("event", event => {
+  if (event.code === "ERROR") console.error(event.error);
+});
+
+process.once("SIGINT", () => watcher.close());
+process.once("SIGTERM", () => watcher.close());
+```
+
+Run `node dev.js`. The helper accepts one Rollup configuration or an array, generates all configured outputs on each rebuild, and forces `watch.skipWrite` without mutating the supplied configuration. Configurations with `watch: false` are ignored.
+
+It returns a Rollup watcher. Use its `END` event to observe completion of generation and build cleanup. The helper owns the build results, so consumers should not call `event.result.generate()` or `event.result.close()`. Output errors are reported through the usual `ERROR` event, and later file changes can trigger another build. `await watcher.close()` waits for pending generation and shuts down the server.
+
+Register watched dependencies in build hooks, such as `buildStart` or `transform`. With `skipWrite`, Rollup collects watch files before `BUNDLE_END`; files first registered in output hooks during the helper's generation are not picked up by the watcher.
+
+Running the same configuration with `rollup -cw` also serves from memory, while continuing to write the usual output files.
+
 Hybrid mode — bundle from memory, static assets from disk:
 
 ```javascript

package/index.d.ts

@@ -41,3 +41,14 @@ declare module '@rollup-extras/plugin-serve' {
 
 	export {};
 }
+
+declare module '@rollup-extras/plugin-serve/watch' {
+	import type { RollupWatcher, RollupWatchOptions } from 'rollup';
+	/**
+	 * Watch and generate Rollup output in memory, closing each build result automatically.
+	 * Configure `serve({ inMemory: true })` in the supplied Rollup configuration.
+	 */
+	export default function watch(config: RollupWatchOptions | RollupWatchOptions[]): RollupWatcher;
+
+	export {};
+}

package/index.js

@@ -36,19 +36,21 @@ export default function (options = {}) {
         normalizedOptions;
     const useWriteBundle = inMemory ? false : normalizedOptions.useWriteBundle;
     const instance = inMemory
-        ? multiConfigPluginBase(useWriteBundle, pluginName, serve, captureOutput)
+        ? multiConfigPluginBase(useWriteBundle, pluginName, serve, captureOutput, resetMemory)
         : multiConfigPluginBase(useWriteBundle, pluginName, serve);
 
     const memoryFiles = new Map();
 
     let currentInputOptions;
 
+    let server;
+
     let { dirs } = normalizedOptions,
         collectDirs = false,
         started = false,
         watchMode = true;
 
-    const pluginInstance = { ...instance, outputOptions };
+    const pluginInstance = { ...instance, outputOptions, closeWatcher };
 
     if (!dirs) {
         dirs = [];
@@ -87,6 +89,11 @@ export default function (options = {}) {
         }
     }
 
+    function resetMemory() {
+        memoryFiles.clear();
+        currentInputOptions = undefined;
+    }
+
     function captureOutput(
          _options,
          bundle,
@@ -138,13 +145,13 @@ export default function (options = {}) {
             app.use('*', serveStatic({ root: dir, ...staticOptions }));
         }
 
-        const server = createAdaptorServer({
+        server = createAdaptorServer({
             fetch: app.fetch,
             ...(https ? { createServer: createHttpsServer, serverOptions: https } : {}),
         });
         globalServer = server;
 
-        const listenCb = () => internalOnListen(server);
+        const listenCb = () => internalOnListen( (server));
 
         if (host) {
             server.listen(port, host, listenCb);
@@ -161,6 +168,14 @@ export default function (options = {}) {
         });
     }
 
+    async function closeWatcher() {
+        if (!server || globalServer !== server) return;
+        globalLiveReload?.close();
+        globalLiveReload = undefined;
+        globalServer = undefined;
+        await new Promise(resolve =>  (server).close(resolve));
+    }
+
     function internalOnListen(server) {
         if (!onListen?.( (server))) {
             logger.finish(`listening on ${linkFromAddress(server.address(), !!https)}`, LogLevel.info);

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.3.1",
+  "version": "2.4.1",
   "license": "MIT",
   "name": "@rollup-extras/plugin-serve",
   "author": "Konstantin Shutkin",
@@ -10,6 +10,10 @@
       "types": "./index.d.ts",
       "default": "./index.js"
     },
+    "./watch": {
+      "types": "./index.d.ts",
+      "default": "./watch.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./index.js",
@@ -35,7 +39,7 @@
     "@niceties/logger": "^2.1.0",
     "@hono/node-server": "^2.0.0",
     "hono": "^4.12.8",
-    "@rollup-extras/utils": "^2.0.0"
+    "@rollup-extras/utils": "^2.0.2"
   },
   "peerDependencies": {
     "rollup": "^4.0.0"

package/watch-exports.d.ts

@@ -0,0 +1,7 @@
+import type { RollupWatcher, RollupWatchOptions } from 'rollup';
+
+/**
+ * Watch and generate Rollup output in memory, closing each build result automatically.
+ * Configure `serve({ inMemory: true })` in the supplied Rollup configuration.
+ */
+export default function watch(config: RollupWatchOptions | RollupWatchOptions[]): RollupWatcher;

package/watch.js

@@ -0,0 +1,93 @@
+import { watch as rollupWatch } from 'rollup';
+
+export default function watch(config) {
+
+    let outputs = [];
+    let closing = false;
+
+    let finishBuild;
+    let pending = Promise.resolve();
+
+    let closed;
+
+    let ready;
+    const initialized = new Promise(resolve => {
+        ready = () => resolve(undefined);
+    });
+    const configs = Array.isArray(config) ? config : [config];
+    const watcher = rollupWatch(
+        configs.map(options => ({
+            ...options,
+            watch: options.watch === false ? false : { ...options.watch, skipWrite: true },
+            plugins: [
+                options.plugins,
+                {
+                    name: '@rollup-extras/plugin-serve/watch',
+                    buildStart() {
+                        outputs = Array.isArray(options.output) ? options.output : [options.output || {}];
+                    },
+                },
+            ],
+        }))
+    );
+    watcher.on('event', async event => {
+        if (event.code === 'BUNDLE_START') {
+            pending = new Promise(resolve => {
+                finishBuild = resolve;
+            });
+            ready?.();
+        } else if (event.code === 'BUNDLE_END') {
+            try {
+                await generate(event.result, outputs);
+            } finally {
+                finishBuild?.();
+            }
+        } else if (event.code === 'ERROR') {
+            try {
+                await event.result?.close();
+            } finally {
+                finishBuild?.();
+            }
+        }
+    });
+
+    function close() {
+        closing = true;
+        closed ||= (async () => {
+
+            await initialized;
+            await pending;
+            await watcher.close();
+        })();
+        return closed;
+    }
+
+    const managed = new Proxy(watcher, {
+        get(target, key) {
+            if (key === 'close') return close;
+            const value = Reflect.get(target, key);
+            if (typeof value !== 'function') return value;
+
+            function call(...args) {
+                const result = value.apply(target, args);
+                return result === target ? managed : result;
+            }
+            return call;
+        },
+    });
+    return managed;
+
+    async function generate(result, outputOptions) {
+        try {
+            if (!closing) {
+
+                const generated = await Promise.allSettled(outputOptions.map(output => result.generate(output)));
+                for (const output of generated) {
+                    if (output.status === 'rejected') throw output.reason;
+                }
+            }
+        } finally {
+            await result.close();
+        }
+    }
+}