clojurific 0.12.6 → 0.12.8

package/README.md

@@ -16,8 +16,8 @@ counts Clojurific's releases, starting from 1.
 
 ## Usage
 
-`npm create clojurific@latest` scaffolds a project (Vanilla, Reagent or UIx)
-like the one below, installs it and starts the dev server.
+`npm create clojurific@latest` scaffolds a project (Vanilla, Reagent, UIx, or
+a Hono backend) like the one below, installs it and starts the dev server.
 
 Dependencies and source paths come from the project's `deps.edn`:
 
@@ -28,10 +28,10 @@ Dependencies and source paths come from the project's `deps.edn`:
 
 ```js
 // vite.config.mjs
-import cljs from 'clojurific/vite';
+import cljf from 'clojurific/vite';
 
 export default {
-  plugins: [cljs({ outputDir: 'target/cljs' })],
+  plugins: [cljf({ outputDir: 'target/cljs' })],
 };
 ```
 
@@ -57,7 +57,7 @@ npx cljf repl
 ```
 
 `cljf repl` is a ClojureScript REPL evaluating in the pages the dev server
-runs, through its nREPL server: `cljs({ outputDir: 'target/cljs',
+runs, through its nREPL server: `cljf({ outputDir: 'target/cljs',
 compilerOptions: { repl: { 'nrepl-port': 0 } } })` with `nrepl/nrepl` in
 `deps.edn`.
 
@@ -87,7 +87,7 @@ npx cljf setup-java
 | `CLJF_MAVEN_REPO` | a Maven Central mirror to download the dependency resolver from; other dependencies use `:mvn/repos` |
 | `CLJF_CACHE_DIR` | where `setup-java` installs Java |
 
-See [ESM.md](https://github.com/WhimsicalCode/clojurific/blob/main/ESM.md) for
+See [README.md](https://github.com/WhimsicalCode/clojurific/blob/main/README.md) for
 compiler options, the Vite plugin's options, the REPL and how the launcher
 works.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clojurific",
-  "version": "0.12.6",
+  "version": "0.12.8",
   "description": "ClojureScript compiled to ES modules, bundled by Vite",
   "license": "EPL-1.0",
   "repository": {

package/vite-plugin-cljs/index.js

@@ -247,12 +247,16 @@ export default module.exports;
  *   true
  * @param {string[]} [options.entries] the :js-entries this build bundles,
  *   defaults to all; each is self-contained when it's the only one
+ * @param {string[]} [options.ssrEntries] :js-entries the dev server runs in
+ *   its ssr environment once they're compiled, i.e. a server's (which a
+ *   plugin like @hono/vite-dev-server imports from the same runner): the REPL
+ *   evaluates in them before their first request
  * @param {boolean} [options.replRemoteConsole] accept cljs_eval (forms the
  *   compiler compiles, running its macros) from pages on other hosts too,
  *   defaults to false: only from this machine. A proxy in front of the dev
  *   server must set X-Real-IP to the client's address.
  */
-export default function cljs(options) {
+export default function cljf(options) {
   const manifestName = options.manifest ?? 'manifest.json';
   let config, proc, server, minify, root, cwd, outputDir, compiler;
   // the namespaces of the pages' scripts, compiled as main namespaces
@@ -324,8 +328,8 @@ export default function cljs(options) {
         } else if (event.type === 'compiled' || event.type === 'error') {
           compiled();
           const logger = config?.logger ?? console;
-          if (event.type === 'error') logger.error(`[cljs] ${event.message}`);
-          else logger.info(`[cljs] compiled ${event.namespaces} namespace(s) in ${event.ms}ms`);
+          if (event.type === 'error') logger.error(`[cljf] ${event.message}`);
+          else logger.info(`[cljf] compiled ${event.namespaces} namespace(s) in ${event.ms}ms`);
           if (first && event.type === 'compiled') {
             first = false;
             resolve();
@@ -398,7 +402,7 @@ export default function cljs(options) {
   }
 
   return {
-    name: 'cljs',
+    name: 'cljf',
     // before Vite's resolver, which would take cljs-npm-as: specifiers
     enforce: 'pre',
 
@@ -619,7 +623,7 @@ export default function cljs(options) {
           this.warn('nothing was pruned: package.json has "type": "commonjs", so the bundler treats the project\'s ' +
             '.js files as CommonJS and wraps the ClojureScript they import in initializers. Use "type": "module".');
         }
-        config.logger.info(`[cljs] removed ${pruned.removed} unused statements (${pruneMs}ms), ` +
+        config.logger.info(`[cljf] removed ${pruned.removed} unused statements (${pruneMs}ms), ` +
           `renamed ${Object.keys(renames).length} properties, ` +
           `minified (${Date.now() - start - pruneMs}ms)`);
       }
@@ -682,56 +686,106 @@ export default function cljs(options) {
       // since: a reloaded page runs the output with warnings
       let problem = null;
       const showProblem = err => {
-        problem = { type: 'error', err: { stack: '', plugin: 'cljs', ...err } };
+        problem = { type: 'error', err: { stack: '', plugin: 'cljf', ...err } };
         server.ws.send(problem);
       };
       server.ws.on('connection', socket => problem && socket.send(JSON.stringify(problem)));
+      // options.ssrEntries run in the ssr environment's runner once compiled,
+      // until they ran
+      let ssrEntries = options.ssrEntries ?? [];
+      const runSsrEntries = async () => {
+        if (!ssrEntries.length) return;
+        // created when it's first read
+        const runner = server.environments.ssr?.runner;
+        if (!runner) return;
+        const info = await buildInfo();
+        for (const name of ssrEntries) {
+          const file = info?.entries?.[name];
+          if (!file) {
+            config.logger.error(`[cljf] ssrEntries: no :js-entries ${name}`, { timestamp: true });
+            continue;
+          }
+          try {
+            await runner.import(path.join(outputDir, file));
+            ssrEntries = ssrEntries.filter(n => n !== name);
+          } catch (e) {
+            config.logger.error(`[cljf] running ${name} (${file}): ${e.stack ?? e}`, { timestamp: true });
+          }
+        }
+      };
       // The REPL (cljf.esm.repl): pages running the build (cljf.esm.repl-runtime)
-      // say hello over Vite's websocket, each connection gets a runtime id. Their
-      // cljs:repl messages go to the compiler as `repl <json>` lines, the
-      // compiler's repl-send events to the page of their runtime id.
+      // say hello over Vite's websocket, and modules the ssr environment's
+      // runner runs (a server's :js-entries) over its hot channel; each
+      // connection gets a runtime id. Their cljs:repl messages go to the
+      // compiler as `repl <json>` lines, the compiler's repl-send events to the
+      // runtime of their runtime id, runtimes[id](data).
       const runtimes = new Map();
       let lastRuntimeId = 0;
       const toRepl = msg => proc.stdin.writable && proc.stdin.write(`repl ${JSON.stringify(msg)}\n`);
-      const send = (socket, data) => socket.send(JSON.stringify({ type: 'custom', event: 'cljs:repl', data }));
-      server.ws.on('connection', (socket, req) => {
-        // cljs_eval compiles forms in the compiler's JVM, which runs their macros:
-        // only for pages on this machine, unless replRemoteConsole
-        const consoleAllowed = options.replRemoteConsole || isLocalConnection(req);
+      // A runtime's connection: receive takes the data of its cljs:repl events
+      // for the REPL, close says bye. send replies to it, consoleAllowed whether
+      // it may cljs_eval.
+      const connectRuntime = (send, consoleAllowed) => {
         let id;
-        socket.on('message', raw => {
-          let msg;
-          try {
-            msg = JSON.parse(String(raw));
-          } catch {
-            return;
-          }
-          if (msg?.type !== 'custom' || msg.event !== 'cljs:repl' || !msg.data) return;
-          const data = msg.data;
+        const receive = data => {
           if (data.op === 'hello' && id === undefined) {
             id = ++lastRuntimeId;
-            runtimes.set(id, socket);
+            runtimes.set(id, send);
           }
           if (id === undefined) return;
-          if (data.op === 'hello') send(socket, { op: 'welcome', runtime: id });
+          if (data.op === 'hello') send({ op: 'welcome', runtime: id });
           if (data.op === 'console-eval' && !consoleAllowed) {
-            send(socket, {
+            send({
               op: 'console-result',
               rid: data.rid,
-              result: { error: 'cljs_eval only runs in pages on the dev server\'s machine, see the cljs plugin\'s replRemoteConsole' },
+              result: { error: 'cljs_eval only runs in pages on the dev server\'s machine, see the cljf plugin\'s replRemoteConsole' },
             });
             return;
           }
           toRepl({ ...data, runtime: id });
-        });
-        socket.on('close', () => {
+        };
+        const close = () => {
           if (id !== undefined && runtimes.delete(id)) toRepl({ op: 'bye', runtime: id });
+        };
+        return { receive, close };
+      };
+      server.ws.on('connection', (socket, req) => {
+        // cljs_eval compiles forms in the compiler's JVM, which runs their macros:
+        // only for pages on this machine, unless replRemoteConsole
+        const runtime = connectRuntime(
+          data => socket.send(JSON.stringify({ type: 'custom', event: 'cljs:repl', data })),
+          options.replRemoteConsole || isLocalConnection(req));
+        socket.on('message', raw => {
+          let msg;
+          try {
+            msg = JSON.parse(String(raw));
+          } catch {
+            return;
+          }
+          if (msg?.type !== 'custom' || msg.event !== 'cljs:repl' || !msg.data) return;
+          runtime.receive(msg.data);
         });
+        socket.on('close', runtime.close);
       });
+      // the ssr runner's modules run in this process, each runner is a client
+      // of the environment's hot channel
+      const ssrHot = server.environments.ssr?.hot;
+      if (ssrHot) {
+        const ssrRuntimes = new Map();
+        const ssrRuntime = client => {
+          if (!ssrRuntimes.has(client)) ssrRuntimes.set(client, connectRuntime(data => client.send('cljs:repl', data), true));
+          return ssrRuntimes.get(client);
+        };
+        ssrHot.on('cljs:repl', (data, client) => data && ssrRuntime(client).receive(data));
+        ssrHot.on('vite:client:disconnect', (data, client) => {
+          ssrRuntimes.get(client)?.close();
+          ssrRuntimes.delete(client);
+        });
+      }
       proc = run(compilerArgs('watch', { ':esm-hmr': true, ':exit-with-parent': true, ':watch-events': ':stdin' }), async event => {
         if (event.type === 'repl-send') {
-          const socket = runtimes.get(event.runtime);
-          if (socket) send(socket, event.msg);
+          const send = runtimes.get(event.runtime);
+          if (send) send(event.msg);
           else toRepl({ op: 'bye', runtime: event.runtime });
           return;
         }
@@ -775,7 +829,7 @@ export default function cljs(options) {
         const outstanding = [...warnings.values()].flat();
         if (event.type === 'compiled' && outstanding.length) {
           const [first] = outstanding;
-          config.logger.warn(`[cljs] compiled ${event.namespaces} namespace(s) in ${event.ms}ms, ` +
+          config.logger.warn(`[cljf] compiled ${event.namespaces} namespace(s) in ${event.ms}ms, ` +
             `hot reload paused by ${outstanding.length} warning(s)`, { timestamp: true });
           showProblem({
             message: outstanding
@@ -786,16 +840,17 @@ export default function cljs(options) {
           });
           ready();
         } else if (event.type === 'compiled') {
-          config.logger.info(`[cljs] compiled ${event.namespaces} namespace(s) in ${event.ms}ms`, { timestamp: true });
+          config.logger.info(`[cljf] compiled ${event.namespaces} namespace(s) in ${event.ms}ms`, { timestamp: true });
           problem = null;
           // the namespaces held back that this compile didn't update
           const client = server.environments.client;
           for (const file of released) {
             for (const mod of client.moduleGraph.getModulesByFile(file) ?? []) client.reloadModule(mod);
           }
+          runSsrEntries();
           ready();
         } else if (event.type === 'error') {
-          config.logger.error(`[cljs] ${event.message}`, { timestamp: true });
+          config.logger.error(`[cljf] ${event.message}`, { timestamp: true });
           showProblem({
             message: event.message,
             id: event.file,