clojurific 0.12.5 → 0.12.7

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`:
 

package/cljf/repl.js

@@ -99,14 +99,27 @@ export function complete(code) {
   return depth <= 0;
 }
 
-/** An nREPL connection: requests whose responses end with status done. */
+/**
+ * An nREPL connection: requests whose responses end with status done. Once the
+ * socket closes, pending and later requests reject.
+ */
 export class Connection {
   #socket;
   #ids = 0;
   #pending = new Map();
+  #closed = null;
 
   constructor(socket) {
     this.#socket = socket;
+    const fail = e => {
+      if (this.#closed) return;
+      this.#closed = new LauncherError(`cljf repl: the nREPL server closed the connection${e ? `: ${e.message}` : ''}`);
+      for (const { reject } of this.#pending.values()) reject(this.#closed);
+      this.#pending.clear();
+    };
+    // an error is followed by close
+    socket.on('error', fail);
+    socket.on('close', () => fail());
     const decoder = new Decoder();
     socket.on('data', chunk => {
       for (const msg of decoder.push(chunk)) {
@@ -132,8 +145,12 @@ export class Connection {
    */
   request(msg, onResponse = () => {}) {
     const id = msg.id ?? this.newId();
-    return new Promise(resolve => {
-      this.#pending.set(id, { onResponse, resolve });
+    return new Promise((resolve, reject) => {
+      if (this.#closed) {
+        reject(this.#closed);
+        return;
+      }
+      this.#pending.set(id, { onResponse, resolve, reject });
       this.#socket.write(bencode({ ...msg, id }));
     });
   }
@@ -247,7 +264,7 @@ export async function repl({
       rl.close();
       // the server forgets the session, unless it doesn't answer
       const timeout = new Promise(r => setTimeout(r, 1000).unref());
-      Promise.race([conn.request({ op: 'close', session }), timeout]).finally(() => {
+      Promise.race([conn.request({ op: 'close', session }), timeout]).catch(() => {}).finally(() => {
         conn.close();
         resolve(code);
       });
@@ -262,7 +279,7 @@ export async function repl({
 
     rl.on('SIGINT', () => {
       if (evaluating) {
-        conn.request({ op: 'interrupt', session, 'interrupt-id': evaluating });
+        conn.request({ op: 'interrupt', session, 'interrupt-id': evaluating }).catch(() => {});
       } else if (pending || rl.line) {
         pending = '';
         interrupted = false;
@@ -307,12 +324,13 @@ export async function repl({
           return;
         }
         evaluating = conn.newId();
+        // a lost connection rejects, closed (above) reports it
         await conn.request({ op: 'eval', session, code, ns, id: evaluating }, msg => {
           write(output, msg.out);
           write(errorOutput, msg.err);
           if (msg.value !== undefined) output.write(`${msg.value}\n`);
           if (msg.ns) ns = msg.ns;
-        });
+        }).catch(() => {});
         evaluating = null;
         if (closing) return;
         prompt();

package/package.json

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

package/vite-plugin-cljs/index.js

@@ -247,6 +247,10 @@ 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
@@ -686,36 +690,52 @@ export default function cljs(options) {
         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(`[cljs] 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(`[cljs] 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' },
@@ -723,15 +743,49 @@ export default function cljs(options) {
             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;
         }
@@ -793,6 +847,7 @@ export default function cljs(options) {
           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 });