clojurific 0.12.4 → 0.12.6

package/cljf/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// cljf: builds and watches ClojureScript with the compiler (cljs.esm), on the
+// cljf: builds and watches ClojureScript with the compiler (cljf.esm), on the
 // project's classpath resolved from its deps.edn. See usage below.
 import { spawn } from 'node:child_process';
 import path from 'node:path';
@@ -10,7 +10,7 @@ import { repl } from './repl.js';
 const usage = `Usage: cljf [options] <command> [arguments]
 
 Commands:
-  build [options...]     compile once, cljs.esm's options: EDN maps, @file.edn
+  build [options...]     compile once, cljf.esm's options: EDN maps, @file.edn
                          and :profile keywords (defaults to :release)
   watch [options...]     compile, then recompile on changes (defaults to :dev)
   classpath              print the project's classpath
@@ -69,7 +69,7 @@ async function main() {
     case 'build':
     case 'watch': {
       const cmd = await compilerCommand({ ...opts, interactive, log });
-      run(cmd.command, [...cmd.args, '-m', 'cljs.esm', command, ...args]);
+      run(cmd.command, [...cmd.args, '-m', 'cljf.esm', command, ...args]);
       break;
     }
     case 'classpath': {

package/cljf/launcher.js

@@ -141,8 +141,8 @@ export async function classpath({ cwd = process.cwd(), aliases = [], force = fal
 
 /**
  * The command starting clojure.main with the compiler on the project's
- * classpath: {command, args, java, classpath}, cljs.esm's arguments go after
- * args, i.e. [...args, '-m', 'cljs.esm', 'build']. Options: cwd (the
+ * classpath: {command, args, java, classpath}, cljf.esm's arguments go after
+ * args, i.e. [...args, '-m', 'cljf.esm', 'build']. Options: cwd (the
  * project, with its deps.edn), aliases, force (resolve the classpath again),
  * interactive (offer to install Java), env and log.
  */

package/cljf/repl.js

@@ -1,7 +1,7 @@
 // cljf repl: a ClojureScript REPL in the terminal, evaluating in the pages
 // running a watched build. It's an nREPL client of the watcher's nREPL server
-// (:repl {:nrepl-port 0}, see cljs.esm.repl.nrepl), whose session it
-// switches to ClojureScript with (cljs.esm.repl/repl).
+// (:repl {:nrepl-port 0}, see cljf.esm.repl.nrepl), whose session it
+// switches to ClojureScript with (cljf.esm.repl/repl).
 import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import net from 'node:net';
@@ -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 }));
     });
   }
@@ -211,14 +228,14 @@ export async function repl({
   const write = (stream, text) => text && stream.write(text);
   const { 'new-session': session } = await conn.request({ op: 'clone' });
   let failed = false;
-  await conn.request({ op: 'eval', session, code: '(cljs.esm.repl/repl)' }, msg => {
+  await conn.request({ op: 'eval', session, code: '(cljf.esm.repl/repl)' }, msg => {
     write(output, msg.out);
     write(errorOutput, msg.err);
     if (msg.ex) failed = true;
   });
   if (failed) {
     conn.close();
-    throw new LauncherError('cljf repl: the nREPL server has no ClojureScript REPL (cljs.esm.repl), is it the dev server\'s?');
+    throw new LauncherError('cljf repl: the nREPL server has no ClojureScript REPL (cljf.esm.repl), is it the dev server\'s?');
   }
 
   const history = terminal ? await readHistory(historyFile) : [];
@@ -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/karma-esm/adapter.js

@@ -1,12 +1,12 @@
-// Karma adapter for a cljs.esm test bundle (an ES module) run by
-// cljs.esm.karma/start. Add it to Karma's files, serve the bundle's directory
+// Karma adapter for a cljf.esm test bundle (an ES module) run by
+// cljf.esm.karma/start. Add it to Karma's files, serve the bundle's directory
 // (included: false), and name its entry module in client.args:
 //
 //   files: ['<this file>', {pattern: 'build/ci-test/**/*', included: false}],
 //   client: {args: ['/base/build/ci-test/my.test-runner.js']},
 //
 // Karma calls start once the page has loaded, module scripts may not have run
-// yet: cljs.esm.karma/start runs the tests in whichever order the two happen.
+// yet: cljf.esm.karma/start runs the tests in whichever order the two happen.
 window.__karma__.start = function () {
   window.__karmaStarted = true;
   if (window.__karmaRun) window.__karmaRun();

package/package.json

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

package/vite-plugin-cljs/index.js

@@ -16,7 +16,7 @@ import { Worker } from 'node:worker_threads';
 import { compilerCommand } from '../cljf/launcher.js';
 import { pruneChunks, propertyRenames } from './prune.js';
 
-const EVENT_PREFIX = '[cljs.esm] ';
+const EVENT_PREFIX = '[cljf.esm] ';
 const NPM_AS = 'cljs-npm-as:';
 // a ClojureScript source loaded by a page or imported from JavaScript, which
 // the dev server serves as an import of its compiled module
@@ -227,11 +227,11 @@ export default module.exports;
  *   the compiler added and stock ClojureScript removed, see cljf/launcher.js.
  * @param {string[]} [options.command] starts Clojure with the compiler on the
  *   classpath instead of the launcher, i.e. ["clojure", "-M:cljs"],
- *   cljs.esm's arguments follow
+ *   cljf.esm's arguments follow
  * @param {string} [options.cwd] the compiler's working directory, with the
  *   project's deps.edn, defaults to Vite's root (the project's directory)
  * @param {string} [options.config] compiler options file (EDN, see
- *   cljs.esm/load-options), relative to cwd
+ *   cljf.esm/load-options), relative to cwd
  * @param {string} [options.profile] profile of the config file, defaults to
  *   dev when serving and release when building
  * @param {string} options.outputDir the compiler's output directory, relative
@@ -285,7 +285,7 @@ export default function cljs(options) {
 
   function run(args, onEvent) {
     const [cmd, ...cmdArgs] = compiler;
-    const child = spawn(cmd, [...cmdArgs, '-m', 'cljs.esm', ...args], {
+    const child = spawn(cmd, [...cmdArgs, '-m', 'cljf.esm', ...args], {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
@@ -686,7 +686,7 @@ export default function cljs(options) {
         server.ws.send(problem);
       };
       server.ws.on('connection', socket => problem && socket.send(JSON.stringify(problem)));
-      // The REPL (cljs.esm.repl): pages running the build (cljs.esm.repl-runtime)
+      // 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.